---
updatedAt: 2026-06-08T06:09:59.000Z
agentTools:
  projectIndex: https://platform.simpplr.com/llms.txt
---

# List people attribute metadata

Returns the set of people (profile) attributes available for the tenant, including standard and custom fields. Use optional query parameters to filter by attribute name and whether the field is filterable in the product.


# OpenAPI definition

```json
{
  "openapi": "3.0.2",
  "info": {
    "version": "1.0.0",
    "title": "Simpplr B2B API Documentation",
    "description": "API documentation for Simpplr B2B integration services",
    "contact": {
      "name": "Simpplr Support"
    }
  },
  "x-proxy-enabled": true,
  "tags": [
    {
      "name": "Feed",
      "description": "Everything about Feed"
    },
    {
      "name": "People",
      "description": "Everything about people"
    }
  ],
  "servers": [
    {
      "url": "https://{endpoint}/v1",
      "variables": {
        "env": {
          "default": "app"
        },
        "endpoint": {
          "default": "platform.app.simpplr.com"
        }
      }
    }
  ],
  "paths": {
    "/b2b/identity/people-attributes": {
      "get": {
        "operationId": "getPeopleAttributesB2B",
        "tags": [
          "People"
        ],
        "summary": "List people attribute metadata",
        "description": "Returns the set of people (profile) attributes available for the tenant, including standard and custom fields. Use optional query parameters to filter by attribute name and whether the field is filterable in the product.\n",
        "parameters": [
          {
            "name": "name",
            "in": "query",
            "required": false,
            "description": "When set, return only the attribute whose external name matches (e.g. `firstName`, `department`, or a custom `field__c` name).",
            "schema": {
              "type": "string",
              "example": "department"
            }
          },
          {
            "name": "isFilterable",
            "in": "query",
            "required": false,
            "description": "When `true` or `false`, filter to attributes that are or are not filterable.",
            "schema": {
              "oneOf": [
                {
                  "type": "boolean"
                },
                {
                  "type": "string",
                  "enum": [
                    "true",
                    "false"
                  ]
                }
              ],
              "example": true
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Success",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "required": [
                    "status",
                    "message",
                    "result"
                  ],
                  "properties": {
                    "status": {
                      "type": "string",
                      "enum": [
                        "success"
                      ],
                      "example": "success"
                    },
                    "message": {
                      "type": "string",
                      "example": "People attributes fetched successfully"
                    },
                    "result": {
                      "type": "object",
                      "required": [
                        "items"
                      ],
                      "properties": {
                        "items": {
                          "type": "array",
                          "description": "Attribute metadata rows for the tenant (after optional filters).",
                          "items": {
                            "type": "object",
                            "description": "A people (profile) attribute visible to the EC / people-attributes API.",
                            "required": [
                              "name",
                              "type",
                              "isMultiValued",
                              "isFilterable"
                            ],
                            "properties": {
                              "name": {
                                "type": "string",
                                "description": "External attribute identifier (camelCase standard names or custom ending with `__c`).",
                                "example": "department"
                              },
                              "type": {
                                "type": "string",
                                "enum": [
                                  "string",
                                  "text",
                                  "enum",
                                  "date",
                                  "email",
                                  "phone",
                                  "url",
                                  "ref"
                                ],
                                "description": "Logical attribute type exposed to API consumers.",
                                "example": "string"
                              },
                              "isMultiValued": {
                                "type": "boolean",
                                "description": "Whether the attribute supports multiple stored values for a user.",
                                "example": false
                              },
                              "isFilterable": {
                                "type": "boolean",
                                "description": "Whether the attribute participates in filtering / distinct-value listing.",
                                "example": true
                              },
                              "isEditable": {
                                "type": "boolean",
                                "description": "Whether end users may edit this field where applicable.",
                                "example": true
                              },
                              "isDisplayable": {
                                "type": "boolean",
                                "description": "Whether the field is intended for display in profile UI when applicable.",
                                "example": true
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Error",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "message": {
                      "type": "string",
                      "description": "Error message describing what went wrong",
                      "example": "The input provided is invalid."
                    },
                    "errors": {
                      "type": "array",
                      "description": "List of validation errors",
                      "items": {
                        "type": "object",
                        "properties": {
                          "message": {
                            "type": "string",
                            "description": "Error message",
                            "example": "Invalid payload"
                          },
                          "details": {
                            "type": "string",
                            "description": "Detailed error message",
                            "example": "The request contains invalid query parameters."
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          },
          "401": {
            "$ref": "#/paths/~1b2b~1rfeed~1feeds/get/responses/401"
          },
          "403": {
            "$ref": "#/paths/~1b2b~1rfeed~1feeds/get/responses/403"
          }
        }
      }
    },
    "/b2b/rfeed/feeds": {
      "get": {
        "operationId": "getFeedsUser",
        "tags": [
          "Feed"
        ],
        "summary": "Get feeds",
        "description": "This API allows you to retrieve all feeds",
        "parameters": [
          {
            "name": "nextPageToken",
            "in": "query",
            "required": true,
            "description": "Token for pagination. \n- For initial request, send empty string \"\"\n- For subsequent requests, use the nextPageToken returned as integer from previous response\n",
            "schema": {
              "type": "string",
              "example": "1759911721822"
            }
          },
          {
            "name": "size",
            "in": "query",
            "required": true,
            "description": "The number of feeds to return per page",
            "schema": {
              "type": "string",
              "example": "16"
            }
          },
          {
            "name": "sortBy",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "enum": [
                "createdAt",
                "lastActivityAt"
              ],
              "default": "createdAt"
            }
          },
          {
            "name": "filter",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "enum": [
                "all"
              ],
              "default": "all"
            },
            "description": "The filter to apply to the feeds"
          },
          {
            "name": "feedContext",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "enum": [
                "home",
                "site",
                "content"
              ],
              "default": "home"
            },
            "description": "The context of the feeds. \n- When set to \"site\", siteId parameter is required\n- When set to \"content\", both siteId and contentId parameters are required\n"
          },
          {
            "name": "type",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "enum": [
                "post",
                "question"
              ],
              "example": "post",
              "description": "The type of feed to return"
            }
          },
          {
            "name": "siteId",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "example": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
            },
            "description": "The ID of the site. \nRequired when feedContext is \"site\" or \"content\"\n"
          },
          {
            "name": "contentId",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "example": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
            },
            "description": "The ID of the content.\nRequired when feedContext is \"content\"\n"
          },
          {
            "name": "feedIds",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "example": "97576a5d-4362-40cb-b8ac-5418b64bf84f,6d54cb3d-da29-461b-8019-3dfb8aa8afe2"
            },
            "description": "The IDs of the feeds to return (send comma-separated list of feed IDs without spaces)"
          },
          {
            "name": "exemptFeedIds",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "example": "97576a5d-4362-40cb-b8ac-5418b64bf84f,6d54cb3d-da29-461b-8019-3dfb8aa8afe2"
            },
            "description": "The IDs of the feeds to exempt from the search (send comma-separated list of feed IDs without spaces)"
          },
          {
            "name": "isSearchForMarkDuplicate",
            "in": "query",
            "required": false,
            "schema": {
              "type": "boolean",
              "example": false
            },
            "description": "Whether to search for mark duplicate feeds(questions)"
          }
        ],
        "responses": {
          "200": {
            "description": "Success",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "status": {
                      "type": "string",
                      "example": "success"
                    },
                    "result": {
                      "type": "object",
                      "properties": {
                        "nextPageToken": {
                          "type": "integer",
                          "example": 1759911721822
                        },
                        "size": {
                          "type": "integer",
                          "example": 10
                        },
                        "total": {
                          "type": "integer",
                          "example": 11
                        },
                        "listOfItems": {
                          "type": "array",
                          "items": {
                            "$ref": "#/paths/~1b2b~1rfeed~1feeds~1{feedId}/get/responses/200/content/application~1json/schema/properties/result"
                          }
                        },
                        "sortBy": {
                          "type": "string",
                          "example": "lastActivityAt"
                        }
                      }
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Error",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "status": {
                      "type": "string",
                      "example": "error"
                    },
                    "message": {
                      "type": "string",
                      "example": "Failed to get feeds"
                    },
                    "errors": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "properties": {
                          "code": {
                            "type": "string",
                            "example": "INVALID_INPUT"
                          },
                          "message": {
                            "type": "string",
                            "example": "An error occurred while processing the request"
                          },
                          "cause": {
                            "type": "string",
                            "example": "size is required"
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          },
          "401": {
            "description": "Authorize error",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "message": {
                      "type": "string",
                      "example": "Missing/Invalid authentication token"
                    }
                  }
                }
              }
            }
          },
          "403": {
            "description": "Forbidden error",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error_code": {
                      "type": "integer",
                      "example": 2001
                    },
                    "message": {
                      "type": "string",
                      "example": "Something went wrong, please try again"
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  },
  "components": {
    "securitySchemes": {
      "OAuth2ClientCredentials": {
        "type": "oauth2",
        "description": "This API uses OAuth 2 with the implicit grant flow.",
        "flows": {
          "clientCredentials": {
            "tokenUrl": "https://platform.{env}.simpplr.xyz/v1/identity/oauth/token",
            "scopes": {}
          }
        }
      }
    }
  },
  "security": [
    {
      "OAuth2ClientCredentials": []
    }
  ]
}
```