---
updatedAt: 2025-05-14T20:26:59.000Z
agentTools:
  projectIndex: https://docs.pipeless.io/llms.txt
---

# Get Activity on Object

Get activity that has taken place on a target object.

## Rate Limits

<Table align={["left","left"]}>
  <thead>
    <tr>
      <th style={{ textAlign: "left" }}>

      </th>

      <th style={{ textAlign: "left" }}>

      </th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td style={{ textAlign: "left" }}>
        Calls per second
      </td>

      <td style={{ textAlign: "left" }}>
        25
      </td>
    </tr>
  </tbody>
</Table>

# OpenAPI definition

```json
{
  "openapi": "3.0.0",
  "info": {
    "title": "Pipeless",
    "version": "1.0"
  },
  "x-samples-languages": [
    "javascript",
    "python",
    "ruby",
    "php",
    "java",
    "node",
    "curl"
  ],
  "servers": [
    {
      "url": "https://api.pipeless.io",
      "variables": {
        "test": {
          "default": "blah",
          "description": "sdfdsdgdf"
        }
      }
    }
  ],
  "paths": {
    "/v1/apps/{app_id}/algos/activity/object": {
      "parameters": [
        {
          "schema": {
            "type": "integer",
            "minimum": 1,
            "default": 123
          },
          "name": "app_id",
          "in": "path",
          "required": true,
          "description": ""
        }
      ],
      "get": {
        "summary": "Get Activity on Object",
        "tags": [
          "Activity"
        ],
        "responses": {
          "200": {
            "description": "OK",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/GetActivityOnObjectResult"
                },
                "examples": {
                  "example-1": {
                    "value": {
                      "events": [
                        {
                          "object": {
                            "id": "photography",
                            "type": "skill",
                            "created_on": "2020-06-03T15:40:22",
                            "modified_on": "2020-06-03T15:40:22"
                          },
                          "relationship": {
                            "type": "interestedIn",
                            "created_on": "2020-09-28T09:31:18"
                          },
                          "direction": "outgoing"
                        },
                        {
                          "object": {
                            "id": "David",
                            "type": "user",
                            "created_on": "2020-03-02T02:11:03",
                            "modified_on": "2020-03-02T02:11:03"
                          },
                          "relationship": {
                            "type": "followed",
                            "created_on": "2020-08-14T09:10:04"
                          },
                          "direction": "incoming"
                        },
                        {
                          "object": {
                            "id": "Article 123",
                            "type": "article",
                            "created_on": "2020-07-05T05:51:02",
                            "modified_on": "2020-07-05T05:51:02"
                          },
                          "relationship": {
                            "type": "liked",
                            "created_on": "2020-09-24T14:20:11"
                          },
                          "direction": "outgoing"
                        }
                      ],
                      "page_info": {
                        "end_cursor": "MTU3NjI1MzU5Nl8yMjM2NjYxOTQ=",
                        "has_next_page": false
                      }
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Bad Request",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Errors"
                }
              }
            }
          },
          "404": {
            "description": "Not Found",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Errors"
                }
              }
            }
          }
        },
        "operationId": "getActivityOnObject",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "default": {
                  "object": {
                    "id": "David",
                    "type": "user"
                  }
                },
                "properties": {
                  "object": {
                    "$ref": "#/components/schemas/ObjectLookup",
                    "description": "Specify the id and type of the object that you want to fetch the activity for."
                  },
                  "relationship_types": {
                    "type": "array",
                    "uniqueItems": false,
                    "description": "Relationship types to include in the fetched activity (will include all by default)",
                    "items": {
                      "$ref": "#/components/schemas/RelationshipType"
                    }
                  },
                  "direction": {
                    "$ref": "#/components/schemas/RelationshipDirection",
                    "description": "Direction of relationships to include in the acitivty on the specified object. If no direciton is speciifed, activity event relationships of both directions will be returned."
                  },
                  "return_cursor_for_events": {
                    "type": "boolean",
                    "description": "This value defaults to false. When set to true, each returned event will contain an additional property called cursor, which contains the cursor value for that specific item. Just like end_cusror in page_info, any cursor value can be used in the before param to begin pagination after the specified cursor."
                  },
                  "limit": {
                    "$ref": "#/components/schemas/PaginationLimit",
                    "description": ""
                  },
                  "before": {
                    "$ref": "#/components/schemas/PaginationBeforeCursor",
                    "description": ""
                  }
                },
                "required": [
                  "object"
                ]
              },
              "examples": {
                "example-1": {
                  "value": {
                    "object": {
                      "id": "Tim",
                      "type": "user"
                    }
                  }
                }
              }
            }
          }
        },
        "description": "Get activity that has taken place on a target object."
      }
    }
  },
  "components": {
    "schemas": {
      "RelationshipWriteable": {
        "title": "",
        "type": "object",
        "properties": {
          "type": {
            "$ref": "#/components/schemas/RelationshipType",
            "description": "The type of relationship for an event. Can be any one of our predefined types. Although it is flexible what relationship type you use, as a best practice, we suggest you pick the one that relates best to the data you are representing. Doing this also allows specific algos to automatically work with their default settings."
          },
          "created_on": {
            "type": "string",
            "format": "date-time",
            "description": "An optional DateTime string in the format YYYY-MM-DDTHH:MM:SS in whatever timezone you use. If not set, and the relationship needs to be created, this value will be set to the current UTC time."
          },
          "single": {
            "$ref": "#/components/schemas/RelationshipSingle",
            "description": "Whether the relationship can be duplicated or not. If single is true (default), then a relationship of each type can only exist once between the same start and end objects. If false, a relationship of the same type can exist multiple times between the same start and end objects."
          }
        },
        "required": [
          "type"
        ]
      },
      "Errors": {
        "title": "",
        "type": "object",
        "properties": {
          "errors": {
            "type": "array",
            "items": {
              "type": "string"
            }
          }
        }
      },
      "RelationshipType": {
        "type": "string",
        "enum": [
          "posted",
          "followed",
          "liked",
          "favorited",
          "saved",
          "unsaved",
          "disliked",
          "purchased",
          "commentedOn",
          "created",
          "viewed",
          "reported",
          "blocked",
          "deleted",
          "authored",
          "used",
          "dismissed",
          "loggedIn",
          "taggedWith",
          "categorizedIn",
          "interestedIn",
          "locatedIn",
          "readQuarter",
          "readHalf",
          "readAll",
          "subscribedTo",
          "subscribedFrom",
          "addedTo",
          "madeBy",
          "pausedOn",
          "updated",
          "enabled",
          "disabled"
        ],
        "title": "",
        "description": "The type of relationship for an event. Can be any one of our predefined types. Although it is flexible what relationship type you use, as a best practice, we suggest you pick the one that relates best to the data you are representing. Doing this also allows specific algos to automatically work with their default settings."
      },
      "ObjectType": {
        "type": "string",
        "title": "",
        "enum": [
          "user",
          "product",
          "image",
          "comment",
          "article",
          "post",
          "video",
          "content",
          "tag",
          "category",
          "app",
          "book",
          "person",
          "skill",
          "job",
          "company",
          "account",
          "card",
          "country",
          "state",
          "film",
          "cart",
          "document",
          "project"
        ],
        "description": "The type of an object. Can be any one of our predefined types. Although it is flexible what object type you use, as a best practice, we suggest you pick the one that relates best to the data you are representing. Doing this also allows specific algos to automatically work with their default settings.",
        "x-examples": {}
      },
      "ObjectReadable": {
        "title": "",
        "type": "object",
        "properties": {
          "id": {
            "$ref": "#/components/schemas/ObjectId"
          },
          "type": {
            "$ref": "#/components/schemas/ObjectType"
          },
          "created_on": {
            "type": "string",
            "format": "date-time"
          },
          "modified_on": {
            "type": "string",
            "format": "date-time"
          }
        },
        "required": [
          "id",
          "type",
          "created_on",
          "modified_on"
        ]
      },
      "ObjectLookup": {
        "title": "",
        "type": "object",
        "properties": {
          "id": {
            "$ref": "#/components/schemas/ObjectId",
            "description": "id of the object you want to fetch."
          },
          "type": {
            "$ref": "#/components/schemas/ObjectType",
            "description": "type of the object you want to fetch."
          }
        },
        "required": [
          "id",
          "type"
        ]
      },
      "ObjectId": {
        "type": "string",
        "title": "",
        "minLength": 1,
        "maxLength": 40
      },
      "PageInfo": {
        "title": "",
        "type": "object",
        "x-examples": {
          "example-1": {
            "end_cursor": null,
            "has_next_page": true
          }
        },
        "properties": {
          "end_cursor": {
            "nullable": true,
            "type": "string"
          },
          "has_next_page": {
            "type": "boolean"
          }
        },
        "required": [
          "end_cursor",
          "has_next_page"
        ]
      },
      "RelationshipDirection": {
        "type": "string",
        "enum": [
          "outgoing",
          "incoming",
          "all"
        ]
      },
      "RelationshipSingle": {
        "title": "",
        "type": "boolean",
        "description": "Whether the relationship can be duplicated or not. If single is true (default), then a relationship of each type can only exist once between the same start and end objects. If false, a relationship of the same type can exist multiple times between the same start and end objects."
      },
      "PaginationBeforeCursor": {
        "title": "",
        "type": "string"
      },
      "PaginationLimit": {
        "title": "",
        "type": "integer"
      },
      "GetActivityOnObjectResult": {
        "title": "",
        "type": "object",
        "properties": {
          "events": {
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "object": {
                  "$ref": "#/components/schemas/ObjectReadable"
                },
                "relationship": {
                  "$ref": "#/components/schemas/RelationshipWriteable"
                },
                "direction": {
                  "$ref": "#/components/schemas/RelationshipDirection"
                },
                "cursor": {
                  "type": "string"
                }
              },
              "required": [
                "object",
                "relationship",
                "direction"
              ]
            }
          },
          "page_info": {
            "$ref": "#/components/schemas/PageInfo"
          }
        },
        "required": [
          "events",
          "page_info"
        ]
      }
    },
    "securitySchemes": {
      "App_API_Key": {
        "name": "Authorization",
        "type": "apiKey",
        "in": "header"
      }
    }
  },
  "security": [
    {
      "App_API_Key": []
    }
  ],
  "x-readme": {
    "explorer-enabled": true,
    "proxy-enabled": true
  }
}
```