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

# Retrieve details of a refund transaction



## OpenAPI

````yaml /marketONE/MarketONEAPIs.yaml get /partnersub/v2/transaction/{transactionId}/refund/{id}
openapi: 3.0.1
info:
  title: MarketONE APIs
  description: >
    The MarketONE OpenAPIs provide a quick and easy way to access MarketONE
    features and your data. These APIs let Resellers (Service Providers) and
    Merchants work together to resell products and handle billing on a single
    platform.


    With an API key, you can authenticate and perform various tasks, like
    accessing and managing data. You can use an HTTP client in any programming
    language to send HTTP requests to MarketONE to create, edit, or delete data.
    The data you work with, like subscriptions or entitlements, are called
    resources, and each resource has its own endpoint (URL).


    The MarketONE OpenAPIs use built-in HTTP features, like HTTP authentication
    and HTTP verbs, which are easy for standard HTTP clients to understand. They
    also use HTTP response codes to indicate errors. All responses, including
    errors, are in JSON format, but our API libraries convert them into objects
    that are specific to the programming language you're using. 


    You can also download the MarketONE OpenAPIs in a YAML file, which is easy
    to read and manage.


    For more information about the MarketONE OpenAPIs, see the [API Reference
    Guide for Merchants](https://docs.saas.amdocs.com/bundle/b_partnerAPIGuide/)
    and the [API Reference Guide for Resellers (Service
    Providers)](https://docs.saas.amdocs.com/bundle/b_aggregatorAPIGuide).


    ## Other MarketONE APIs


    Other MarketONE APIs, such as the [Reseller (CSP) Adapter
    OpenAPIs](https://docs.saas.amdocs.com/bundle/MarketONECSPAdapter/page/index.html),
    the [Merchant (OTT) Service
    Callbacks](https://docs.saas.amdocs.com/bundle/MarketONEOTTServiceCallbacks/page/index.html),
    and the [Commerce Gateway
    OpenAPIs](https://docs.saas.amdocs.com/bundle/Amdocs_Media-Commerce-Gateway-Latest-resolved/page/index.html),
    are available to provide additional services for specific organizations.


    # Environments


    MarketONE provides two distinct environments for testing and production:

    - **Prodtest environment**: this is a pre-production environment allowing
    you to test your application with test data. Use server
    <https://int-prodtest.m1amdocs.io/>.

    - **Production environment**: this is the live environment for the
    real-world implementation of  data. Use server <https://int.m1amdocs.com/>.


    # HTTP Verbs


    The MarketONE OpenAPIs support the following HTTP verbs:

    - **GET**: Retrieve resources (as a list or single record fetch).

    - **POST**:  Create new resources or update existing ones (overloading
    during create/update is permitted where specified).

    - **PUT**: Create a new resource or replace a resource with the request
    payload.

    - **DELETE**: Remove ownership or hierarchical association between certain
    resources.


    #  Example

     ## Request Example

     ```
    POST /v1/entitlement 

    Content-Type: application/json

    {
      "account": {
        "id": "2922fbf1-1dc4-2293-9d0e-c9a46630ad6e"
      },
      "subscriptionId": "ef1917b8-4a06-4595-9998-718799a33ed6",
      "productCodes": [
        "Basic_Addon"
      ],
      "metadata": {
        "email": "j.smith@email.com"
      }
    }

    ```

      ## Response Example

    ```

    Response: 200 OK

    Content-Type: application/json

    [
      {
        "partnerSubscriptionId": "80e08955-b0e9-4ba6-b882-b24230bfc703",
        "account": {
          "id": "0006fbf1-1ac4-4793-9d0e-c0a0080ad6e",
          "partnerCustomerId": "1bbbb3a5-0f05-4009-b4ae-b01f7eba7g"
        },
       "subscriptionId": "ef1417b8-4a06-7775-8518-718714a33ed2",
        "externalPartnerSubscriptionId": "7d50531-31eb-45f9-91ce-6355250f5501",
        "partnerCode": "PRTNR",
        "productCode": "Basic_Addon",
        "createdDate": "2024-05-04T17:38:10.889",
        "updatedDate": "2024-05-04T17:38:11.160",
        "startServiceDate": "2024-05-04T17:38:10.889",
        "serviceStatus": "PROVISION-COMPLETE"
      }
    ]

    ```


    # Status Codes


    MarketONE uses the following HTTP response codes to indicate the success or
    failure of an API request.


    | Code | Status | Description |

    | -------  | ------   | ------------------- |

    | **200** | OK | Everything worked as expected. |

    | **201** | OK | Everything worked as expected. |

    | **400** | Bad Request | The request was unacceptable, often due to missing
    a required parameter. Other possibilities include: <ul><li>A parameter
    doesn't fit the data type</li><li>A parameter is outside the maximum or
    minimum boundaries of what can be accepted.</li> |

    | **401** | Unauthorized | Couldn’t authenticate your request. This could be
    due to a wrong or invalid API key. |

    | **403** | Forbidden | Authentication failed. Check your username and
    password. |

    | **404** | Not Found | The requested resource doesn’t exist. |

    | **409** | Conflict | |

    | **429** | Too Many Requests | Too many requests were made to the API too
    quickly. |

    | **500** | Internal Server Error  | |

    | **501** | Not Implemented | |

    | **503** | Service Unavailable | We’re temporarily offline for maintenance.
    Please try again later. |


    # Authentication


    API keys are required to make requests to the MarketONE OpenAPIs. In Partner
    Ecosystem Management, Resellers (Service Providers) can conveniently
    [generate an API
    key](https://docs.saas.amdocs.com/bundle/b_userGuideForResellers/page/topics/apiKeysAggregatorManage_t.html).
    Merchants can also [generate an API key for each Reseller (Service Provider)
    partnership](https://docs.saas.amdocs.com/bundle/b_userGuideForMerchants/page/topics/apiKeysManage_t.html)
    in Partner Ecosystem Management. After you authenticate with your API
    key(s), you can access resources through the MarketONE OpenAPIs.


    Each API key is a JSON Web Token (JWT) that doesn't expire. For every API
    call you make to the MarketONE OpenAPIs, the API key must be included in the
    header (`X-API-KEY`) of the call to ensure trusted communication. All
    communication is HTTP(s) based and supports SSL/TLS encryption.


    # Errors


    All error responses will return an error object.


    # Attributes


    | Name | Type | Required/Optional | Description |

    | -------  | ------ | ------ | ------ |

    | **code** | string | required | The error type, such as
    "authentication-required" (401) or "not-found" (404). |

    | **message** | string | required | A human-readable message providing more
    detailed information about the error. |

    | **validationErrors** | object | optional | An array of validation errors
    with **code** and **message** attributes provided. |
  license:
    name: Amdocs Inc.
    url: http://www.amdocs.com
  version: Released
servers:
  - url: https://int-prodtest.m1amdocs.io/
    description: Sandbox server (uses test data)
  - url: https://int.m1amdocs.com/
    description: Production server (uses live data)
security: []
paths:
  /partnersub/v2/transaction/{transactionId}/refund/{id}:
    get:
      tags:
        - partnerSubscription
        - transaction
      summary: Retrieve details of a refund transaction
      operationId: getRefund
      parameters:
        - name: transactionId
          in: path
          description: >-
            The extTransactionID parameter is the transaction ID on which the
            original transaction was processed.
          required: true
          style: simple
          explode: false
          schema:
            maxLength: 36
            type: string
        - name: id
          in: path
          description: >-
            The extTransactionID parameter is the transaction ID on which the
            original refund was processed.
          required: true
          style: simple
          explode: false
          schema:
            maxLength: 36
            type: string
      responses:
        '200':
          description: |
            *OK* - Refund details successfully retrieved
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/OTTRefundResponse'
        '400':
          description: bad request
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/400ErrorBasic'
        '401':
          description: authorization failure
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/401Error'
        '404':
          description: not found
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GETRefundErrorResponse404'
        '500':
          description: internal server error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/500Error'
      security:
        - ApiKeyAuth: []
components:
  schemas:
    OTTRefundResponse:
      type: object
      properties:
        id:
          $ref: '#/components/schemas/ID'
        created:
          type: string
          description: The date/time at which the refund was requested.
          format: date-time
        amount:
          type: number
          description: >-
            Amount of the refund. Must be positive (non-zero) and less than or
            equal to the as-yet-un-refunded balance of the specified
            transaction. Ignored if refundItems are specified.
        currency:
          type: string
          description: >-
            The [ISO 4217](http://en.wikipedia.org/wiki/ISO_4217) Currency Code
            of this transaction; defaults to USD.
        note:
          type: string
          description: Free-form specified note about refund.
        refund_distribution_strategy:
          type: string
          description: >-
            Defines strategy for distributing refund amount across the original
            TransactionItems. Default is None.
          enum:
            - SpecifiedItems
            - None
        refund_items:
          type: array
          description: >-
            For item-level refunds, specifies the transaction items to refund
            with details.
          items:
            $ref: '#/components/schemas/OTTRefundItem'
        metadata:
          $ref: '#/components/schemas/METADATA'
      description: >-
        The Refund object provides a way to reverse a charge, refunding money to
        the customer. You can create, and retrieve individual Refunds; as well
        as list all existing Refunds. Refunds require a transaction – a refund
        can only be executed against an existing, successfully captured
        transaction. Refunds can be issued for any valid amount (in the currency
        of the original transaction) up to the as-yet un-refunded balance of the
        original transaction. You can issue any number of refunds on a given
        transaction (until it has been fully refunded).
    400ErrorBasic:
      required:
        - code
      type: object
      properties:
        code:
          type: string
          enum:
            - invalid-request
        message:
          type: string
    401Error:
      required:
        - code
      type: object
      properties:
        code:
          type: string
          enum:
            - authentication-required
            - invalid-api-key
            - api-key-not-found
        message:
          type: string
    GETRefundErrorResponse404:
      required:
        - code
      type: object
      properties:
        code:
          type: string
          description: a code that identifies error
          enum:
            - refund-transaction-not-found
        message:
          type: string
          description: A message which describes the error in details
          enum:
            - refund transaction not found
    500Error:
      required:
        - code
      type: object
      properties:
        code:
          type: string
          enum:
            - server-error
        message:
          type: string
    ID:
      maxLength: 128
      type: string
      description: A unique identifier.
    OTTRefundItem:
      required:
        - amount
        - code
      type: object
      properties:
        code:
          type: string
          description: >-
            Code on the original transaction line item. If the code is passed
            in, and can be used to uniquely identify the transaction item, it
            will be used, otherwise an error will be returned. Code must be
            TOTAL_TAX for tax refund items.
        amount:
          type: number
          description: >-
            Amount of the requested refund for this item, in the currency of the
            overall transaction. This amount must not exceed the original
            TransactionItem amount, minus any discounts and minus the sum of all
            prior refunds against this item.
        metadata:
          $ref: '#/components/schemas/METADATA'
    METADATA:
      type: object
      additionalProperties:
        type: string
        properties:
          key:
            type: string
          value:
            type: string
      description: >-
        A set of key/value pairs that you can attach to an object. Useful for
        storing additional information.
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      description: The authorization key obtained from MarketONE.
      name: X-API-KEY
      in: header

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.