POST /profile_activities • Credits: 2 credits per returned activity item

The RichAPI Profile Activities API returns the recent LinkedIn activity of one person. Send a POST request to /profile_activities with the LinkedIn URN of that person. The response returns each post, comment or reaction with its text, its URL, its date and its engagement counts. Each returned activity item costs 2 credits, which is $0.04 on the 1,000 and 5,000 credit packs.

What does Profile Activities do?

Profile Activities reads the public activity feed of one LinkedIn person profile. A sales team needs a reason to contact a prospect. The last post of that prospect is that reason. Profile Activities returns those items as JSON, so a script can read them without a browser. The data source is LinkedIn. The endpoint is synchronous, so the response arrives in the same HTTP call and needs no polling and no webhook. One call covers one person and returns one page of activity.

Which endpoint does Profile Activities use?

Method:POST
URL:https://api.richapi.ai/api/v1/profile_activities
Authentication:x-api-key header
Request format: JSON request body
Response: Synchronous JSON
Pagination: Cursor token
Credits: 2 credits per returned item

Profile Activities accepts the POST method only. Every parameter goes in the JSON request body. If you send another method, the API returns 405 with the message profile_activities only supports POST.

How to send a Profile Activities request

Copy your API key from the RichAPI dashboard.
Set the x-api-key header to that API key.
Set the Content-Type header to application/json.
Put the LinkedIn entity URN of the person in the urn field of the request body.
Set type to POST, COMMENT or REACTION to filter the activity.
Set limit to the number of activity items you want in one page.
Send the request to https://api.richapi.ai/api/v1/profile_activities.
Read the activity items from the elements array in the response.

cURL

curl -X POST https://api.richapi.ai/api/v1/profile_activities   
  -H "x-api-key: YOUR_API_KEY"   
  -H "Content-Type: application/json"   
  -d '{
    "urn": "ACoAACcJ11oB9WoP2-S-clw3Q64H9_WmNjCJbbk",
    "type": "POST",
    "limit": 10
  }'

Python

import requests

response = requests.post(
    "https://api.richapi.ai/api/v1/profile_activities",
    headers={"x-api-key": "YOUR_API_KEY"},
    json={
        "urn": "ACoAACcJ11oB9WoP2-S-clw3Q64H9_WmNjCJbbk",
        "type": "POST",
        "limit": 10,
    },
    timeout=60,
)
response.raise_for_status()
print(response.json())

Node.js

const response = await fetch("https://api.richapi.ai/api/v1/profile_activities", {
  method: "POST",
  headers: {
    "x-api-key": "YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    urn: "ACoAACcJ11oB9WoP2-S-clw3Q64H9_WmNjCJbbk",
    type: "POST",
    limit: 10,
  }),
});

const data = await response.json();
console.log(data);

Which parameters does Profile Activities accept?

Profile Activities accepts four parameters. All four go in the JSON request body.

Parameter	Type	Required	Default	Description
`urn`	string	Yes	none	The LinkedIn entity URN of the person profile, for example `ACoAACcJ11oB9WoP2-S-clw3Q64H9_WmNjCJbbk`.
`type`	string	No	`""`	The activity type filter. The accepted values are `POST`, `COMMENT` and `REACTION`.
`pagination_token`	string	No	`""`	The cursor token from the previous response. It returns the next page.
`limit`	integer	No	none	The number of activity items in one page. Send `1` or more on every request. A value below `1` returns `400` with the message `limit must be at least 1.`

Profile Activities rejects a request body key that is not one of these four names. The API returns 400 with the message Unknown input field(s): <name> and a supported_fields object.

Which values does the type parameter accept?

The type parameter of Profile Activities filters the activity feed to one kind of item.

Value	What Profile Activities returns
`POST`	The posts that the profile published.
`COMMENT`	The comments that the profile wrote.
`REACTION`	The reactions that the profile gave.
`""`	All three activity types. The empty string is the default.

Send one of the values in this table. RichAPI does not check the value, and an unlisted value returns no useful filter.

What does Profile Activities return?

Profile Activities returns a JSON object with an elements array. Each item in the array is one post, one comment or one reaction. The block below is an example response for one post.

{
  "elements": [
    {
      "url": "https://www.linkedin.com/feed/update/urn:li:activity:7253037834318532608/",
      "text": "We shipped the new billing dashboard this week. Invoice errors dropped by 40 percent in the first month.",
      "type": "POST",
      "likeCount": 142,
      "publishedAt": "2026-07-28T09:15:00.000Z",
      "commentCount": 18
    }
  ]
}

Which fields does the Profile Activities response hold?

Field	Type	Description
`elements`	array	The list of activity items.
`elements[].url`	string	The LinkedIn URL of the activity.
`elements[].text`	string	The post text or the comment text.
`elements[].type`	string	The activity type: `POST`, `COMMENT` or `REACTION`.
`elements[].likeCount`	integer	The number of likes on the activity.
`elements[].publishedAt`	string	The publication timestamp of the activity.
`elements[].commentCount`	integer	The number of comments on the activity.

How do I page through Profile Activities results?

Profile Activities pages with a cursor token, and not with a page number. One call returns one page of activity items. The response carries a paginationToken value for the next page. Send that value in the pagination_token parameter of the next request, and keep every other parameter the same.

curl -X POST https://api.richapi.ai/api/v1/profile_activities   
  -H "x-api-key: YOUR_API_KEY"   
  -H "Content-Type: application/json"   
  -d '{
    "urn": "ACoAACcJ11oB9WoP2-S-clw3Q64H9_WmNjCJbbk",
    "type": "POST",
    "limit": 10,
    "pagination_token": "dXJuOmxpOmFjdGl2aXR5OjcyNTMwMzc4MzQ"
  }'

CAUTION: Set a stop condition before you page through a full activity history. Each returned item costs 2 credits, so a page of 10 items costs 20 credits.

How much does Profile Activities cost?

Profile Activities costs 2 credits per returned activity item. One credit is $0.02 on the 1,000 and 5,000 credit packs, so one item is $0.04 there. Larger packs cost less per credit. A page of 10 items costs 20 credits. A page with no items costs 0 credits.

Items returned	Credits	Cost
1	2	$0.04
10 (one page of 10)	20	$0.40
100	200	$4.00
1,000	2,000	$40.00

RichAPI charges 2 credits for each item in a 200 response. A failed call is not billable, so a 4xx or 5xx response costs 0 credits.

How do I check a prospect before outreach?

Profile Activities gives the opening line of an outreach message. Follow these steps for one prospect.

Send a Profile Enrichment request with the LinkedIn profile URL of the prospect.
Read the entityUrn value from the Profile Enrichment response.
Send a Profile Activities request with that value in the urn parameter.
Set type to POST to get the posts that the prospect published.
Set limit to 10 to get the ten most recent items.
Read publishedAt on each item to find the newest activity.
Read text on that item to find the subject of the post.
Name that subject in the first line of the outreach message.

With limit set to 10, the two calls cost up to 21 credits. Profile Enrichment costs 1 credit, and Profile Activities costs 2 credits for each of up to 10 items. For 500 prospects the workflow costs up to 10,500 credits, which is $210.00 on the 1,000 and 5,000 credit packs. Set limit to 3 to cut that to 3,500 credits.

Set type to COMMENT for a second signal. A comment shows the topics that the prospect follows, and the people that the prospect answers.

Which errors does Profile Activities return?

Status	Meaning	What to do
`400`	The request body failed validation, or it holds an unknown key.	Correct the parameter that the message names. Read `supported_fields.accepted` for the accepted names.
`401`	The API key is missing, wrong or revoked.	Send a valid key in the `x-api-key` header.
`402`	The organization has no credits left (`Insufficient credits`), or the team reached its monthly spend limit (`Monthly spend limit reached`).	Buy credits in the RichAPI dashboard.
`403`	`Endpoint not available on your plan`: this API key has no access to this endpoint.	Call `GET /api/v1/my-endpoints` to list the endpoints this key can use. For access, write to [email protected].
`405`	The request used a method other than `POST`.	Send the request again with the `POST` method.
`429`	Too many requests.	Wait, then send the request again.
`500`	The API failed.	Send the request again. If the failure repeats, write to [email protected].

Frequently asked questions

Where do I find the LinkedIn URN for Profile Activities?

Send a Profile Enrichment request with the LinkedIn profile URL. The response returns an entityUrn value in the ACoA... format, and that value is the urn parameter of Profile Activities.

Does Profile Activities charge per activity item?

Yes. Profile Activities charges 2 credits for each returned activity item. A call that returns 10 items costs 20 credits. A call that returns 1 item costs 2 credits.

How do I get only the comments of a LinkedIn profile?

Set the type parameter of Profile Activities to COMMENT. The response then holds comment items only, and every item carries the comment text in the text field.

Why does Profile Activities return a 400 with Unknown input field(s)?

The request body holds a key that is not a Profile Activities parameter. The four accepted names are urn, type, pagination_token and limit, and the supported_fields.accepted list in the error body repeats them.

Can I turn off the cache for Profile Activities?

No. Profile Activities has no cache parameter. A response can hold data that is up to 24 hours old.

How fast can I send Profile Activities calls?

The rate limit follows the credits that the account buys in a month, from 1 request a second on the Sandbox to 50 requests a second from 100,000 credits. A request over the limit gets a 429 with a Retry-After header.