Rapattoni Developer Resources

Rapattoni Magic API

Rapattoni offers an API, for Cloud Magic customers, that supports data access using OAuth2 authentication and OData v4 queries.


Magic API access is secured via OAuth2; a transaction with our identity server is required to obtain the necessary bearer token. Currently only the Client Credential grant type is supported.

Authentication URL Example:

  • https://api.rapmagic.com/IDServer/identity/connect/token?type=ams&cust=cust

For Client Credential Grant access, the following parameters must be passed in the Body of a POST transaction:

  • grant_type: Client Credential access will always use the client_credentials grant type.
  • client_id: An id provided by the Association staff.
  • client_secret: A value provided by the Association staff, associated with the client_id.
  • scope: Provided by the Association staff. This must match a scope that the API recognizes and that is approved for usage by your credentials. It is part of what defines what you can access in the API.

The raw Body of the request should look similar to the following example:

  • grant_type=client_credentials&client_id=ClientID&scope=Scope&client_secret=Secret

You will also need to include the header:Content-Type: application/x-www-form-urlencoded and ensure that the values contained in the body of the request are properly URL-encoded.

If the transaction is successful, then the response body will be a JSON object containing the access token, the token expiration date, and the token type. The token type will always be “bearer”, and the time till the token expires is set by the association, on a client by client basis, based upon their rules and regulations.

API Transactions

All transactions must include the Authorization header with the value being the client’s current bearer token obtained from the transaction with our identity server.

Here is an example of the how the Authorization header with the bearer token should appear in the HTTP request. Please note that the actual token hash will be substantially longer:

  • Authorization: bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiI

Depending on your setup you may need to preemptively URL encode your query. The following is an example of the URL with an encoded query segment:

  • https://api.rapmagic.com/cust/odata/Members?%24select=MemberKeyNumeric%2CMemberFirstName%2CMemberLastName%2CMemberNationalAssociationId%2COfficeName

The Magic API utilizes standard OData URIs and commands (ODatav4).

Responses, unless otherwise specified, will be in the JSON format.

Service and Metadata

The Service Document is available via a get request against the root URL (https://api.rapmagic.com/cust/odata). This document is a standard OData resource listing all top-level entity sets exposed by the service.( ODatav4 10.1)

Querying this endpoint will return a JSON array of all directly queryable entities. Each object will have the following properties:

  • Name matches the name of the entity in the metadata.
  • Kind is the type of object being described.
  • Url is the end point to use in the URL for access.

         "name": "Members",
         "kind": "EntitySet",
         "url": "Members"
          "name": "MemberAssociation",
           "kind": "EntitySet",
           "url": "MemberAssociation"

The Metadata Document is available via a get request against the root URL with “/$metadata” appended (i.e. https://api.rapmagic.com/cust/odata/$metadata). This resource describes the API’s data model; including data types, relationships between entity sets, and available fields (ODatav4 11.1.2). This resource is only available in the XML format.

Each entity definition will begin with the <EntityType> tag containing the Name of the entity.

    <EntityType Name="Members">
The first child element listed under the EntityType tag will be the Key definition, this tag will contain child elements defining the key field(s) for the entity. Keys can be used to target a specific record in an entity.

        <PropertyRef Name="MemberKeyNumeric" />
The next elements will describe the properties of the entity, these define the available fields and should include the field’s datatype, maximum character length (if applicable), and an annotation containing a plan text description.

    <Property Name="MemberFirstName" Type="Edm.String">
        <Annotation Term="Magic_API.Models.Data.Description" String="The first name of the Member." />
The final elements will be the navigation properties. These define entities that can be expanded to. They contain the Name of the navigation property, the Type of the entity and possible Referential Constraints.

    <NavigationProperty Name="Offices" Type="Magic_API.Models.Data.Offices">
        <ReferentialConstraint Property="OfficeKeyNumeric" ReferencedProperty="OfficeKeyNumeric" />
    <NavigationProperty Name="PhoneNumbers" Type="Collection(Magic_API.Models.Data.PhoneMember)" />
  • Name is the value used in the $expand clause. So to expand to the Offices entity in this case you would use $expand=Offices
  • Type is full name of the entity targeted by the navigation property. While PhoneNumbers is the name of a navigation property above, it’s actually targeting the entity PhoneMember. This means you would look in the metadata for the Entity Type named PhoneMember for more information regarding the entity that navigation property is targeting. If the Type starts with the word Collection, then the mapping between the entity and the navigation property entity is one-to-many (i.e. one record may map to many records, e.g. one member may map to many phone numbers).
  • ReferentialConstraint references the field(s) being used to link records in the two resources; also known as the Foreign Key. In this case the example entity and Offices have an OfficeKeyNumeric field linking them. Usually this reference only appears if the field is not one of the source entity’s keys.

Query Support

Entity Set Queries: All Entity Set queries use the default OData format; the root URL is appended with “/EntitySet” (i.e. to query the Offices Entity Set: https://api.rapmagic.com/cust/odata/Offices)
When Querying against Entity Sets, the Magic API Supports most OData 4 query options, functions and operators. The below list are those query options and some of their associated supported functions and operators. Please see the OData 4 specification for further information in regards to these:

  • $expand: allows for the inclusion of entities related to the base entity set queried. The relationships between entity sets can be found in the metadata document. Multiple entities can be included with comma delimiting. If the relationship is further than 1 degree of separation than the full path to the targeted entity must be included. (ODatav4
    • Members?$expand=MemberDesignations: this will return Member records and their related MemberDesignations entries. The Metadata will show Members and MemberDesignations are via MemberKeyNumeric.
    • Members?$expand=MemberDesignations($expand=Designations): this will return Member records, their related MemberDesignations entries and the related information to describe the Designations. The Members set links to MemberDesignations via MemberKeyNumeric and the MemberDesignations set links to Designations on the MemberDesignation key.
  • $select: specify fields to be returned, if not included all fields will be returned. For selecting fields from expanded entity set relationships, the select is included with the expanded item. (ODatav4
    • Members?$select=MemberKeyNumeric,MemberFirstName
    • Members?$expand=MemberDesignations($select=MemberDesignation)&$select=MemberKeyNumeric,MemberFirstName
  • $top: specify the number of entities to return (ODatav4
    • Members?$top=10
  • $skip: skip over the first n entities prior to returning data (ODatav4
    • Members?$skip=10
  • $orderby: order the results by a specific field’s value; use asc or desc to specify ascending or descending. To order by multiple criteria use comma delimiting(ODatav4
    • Members?$orderby=MemberFirstName asc
    • Members?$orderby=MemberFirstName asc, OfficeName desc
  • $count: $count=true specifies that the total count of entities matching the request must be returned along with the results (ODatav4
    • Members?$count=true
  • $filter: restrict the returned entities to only those matching the filter criteria (ODatav4
    • Operators
      • eq: Equal
      • ne: Not equal
      • gt: Greater than
      • ge: Greater than or equal
      • lt: Less than
      • le: Less than or equal
      • and: Logical and
      • or: Logical or
      • not: Logical negation, used in conjunction with other functions and operators to create a negative comparison.
      • add: add to modify a numeric field and utilize the result for comparisons.
      • sub: subtract to modify a numeric field and utilize the result for comparisons.
      • mul: multiply to modify a numeric field and utilize the result for comparisons.
      • div: divide to modify a numeric field and utilize the result for comparisons.
      • (): Functions and operators can be nested using parentheses for precedence.
    • Functions
      • contains: string contains, syntax is: contains(FieldName,’string’)
      • endswith: string ends with, syntax is: endswith(FieldName,’string’)
      • startswith: string starts with, syntax is: startswith(FieldName,’string’)
      • substring: string contains, syntax is: substring(FieldName,1) eq 'string'
      • tolower: string to lower casing
      • toupper: string to upper casing
      • trim: trim all leading and trailing white spaces from a string
      • concat: append one string value to another
      • day: return the day component from a DateTimeOffset or Date
      • hour: return the hour component from a DateTimeOffset
      • minute: return the minute component from a DateTimeOffset
      • second: return the second component from a DateTimeOffset
      • month: return the month component from a DateTimeOffset or Date
      • year: return the year component from a DateTimeOffset or Date
    • Complex Filter Example:
      • Offices?$filter=(endswith(Office_Name,'Realty') and Street_City eq 'Ventura') or Salespersons add 5 gt 10
  • &: Multiple query options can be included at once, each separated by an “&”
    • Example: Members?$expand=MemberDesignations($select=Designations)&$top=50&$select=MemberKeyNumeric
  • Paging: Server paging is enabled; the server will limit the number of records that it sends in a single response.
    • @odata.nextLink: If the number of records matching the query parameters is greater than the number of records the server is capable of returning, then the results will include the “@odata.nextLink” JSON object. This object will usually exist at the end of the current result and will contain the exact URL and query parameters needed to obtain the next page of matching records. If this object is not included in the result, then there are no additional pages available.
      Paging Example
      "@odata.context": "https://api.rapmagic.com/CUST/odata/$metadata#Members(MemberCity)",
                  "MemberCity": "Somewhere"
                  "MemberCity": "Elsewhere"
                  "MemberCity": "Somewhere"
      "@odata.nextLink": "https://api.rapmagic.com/cust/odata/Members?$select=MemberCity&$skip=500"

  • Single Entity: To return one specific Entity, the format is EntitySet(key). For example, if pulling back member number 100 from the Members entity set, the root URL would be appended with /Members(100). Some Entity Sets have multiple primary keys, in such cases the request format would be EntitySet(keyfield1=intvalue,keyfield2='charvalue',...). Please refer to the metadata to find the primary key(s) for each Entity Set.
    • Example: https://api.rapmagic.com/cust/odata/Members(100)
    • Example: https://api.rapmagic.com/cust/odata/InternetInformation(RecordKey=4,RecordType='MI',Association='ASOC')

Update Transactions

Records are Updated via an HTTP PATCH request against a Single Entity.

Required Headers: The following headers MUST be included with their respective values:

  • Authorization:bearer token
  • Content-Type:application/json

  • Optional Headers: By Default a successful PATCH request will return a 204 response. If you wish for the record targeted to be returned with a 200 response instead, you may use the following Header:Value :

  • Prefer:return=representation
  • Note that you may include OData query criteria in the URL,such as $select, to narrow the fields shown in the result set when using the optional Prefer header.

    The body of the request must be a JSON object with the following format (quotes included): {"FieldName":"NewValue"}

    Multiple fields may be modified at once with comma delimiting: {"FieldName1":"NewValue1","FieldName2":"NewValue2"}

    HTTP Response Codes

    Identity Server

    Code Text Description





    Bad Request
    “error: unsupported_grant_type”

    The grant type entered during Authentication is not supported.


    Bad Request
    “error: invalid_client”

    The client secret included is invalid.


    Internal Server Error

    Likely the cust query string value is incorrect or the client_id is invalid.

    Magic API

    Code Text Description





    Bad Request
    “The request is badly formed.”

    Likely the query needs to be URL encoded.


    Bad Request
    “The query parameter 'x' is not supported.”

    The given query parameter is not valid.


    Bad Request
    "Could not find a property named 'x' on type 'entityset'."

    The given property doesn’t exist in the entity set being queried.


    “Authorization has been denied for this request.”

    The bearer token passed is expired or invalid.


    Not Found

    An invalid resource was targeted


    Internal Server Error

    Most likely occurs due to an issue on the server side.

    Available API Fields