SOCIAL MEDIA

Chatous Get Account State API

Read a Chatous account's own profile, its open conversations and their message history in one bounded WebSocket read. Chatous exposes no REST endpoint for any of this, so the socket's opening burst is the only source.

chatousprofileconversationsmessages

Try it free Get an API key

How to call it

Send one POST to api.upapi.io/chatous-get-account-state.get with your key in the X-Api-Key header and the parameters below as a JSON body. Each call spends 4 weighted units of your monthly quota. The operation times out after 40 seconds. Responses are not cached; every call runs the operation.

endpoint

POST https://api.upapi.io/chatous-get-account-state.get

Chatous Get Account State API reference

Request parameters

proxyUrl: string — Optional proxy URL for the WebSocket. Omit to connect directly. Pass the exit the account normally uses if you keep one per account.
connectSid: stringrequired — The account's connect.sid cookie value, as set on chatous.com when the account signed in.
maxSeconds: number — How long to hold the socket open collecting the opening burst. Raise it for an account with many conversations; the call returns early once the server stops sending.
maxMessages: integer — Cap on collected socket frames, so a very busy account cannot stream on.

Response fields

profile: objectrequired — The account's own profile as Chatous pushed it, or null when the burst carried none. Null means 'not sent in this window', never 'no profile'.
messages: arrayrequired — Message history for the conversations above, oldest first as received.
messages[].chatId: stringrequired
messages[].fromMe: booleanrequired — True when this account sent it, from Chatous's own is_me flag.
messages[].message: stringrequired
elapsedMs: integerrequired
fetchedAt: stringrequired
frameCount: integerrequired — Raw socket frames collected, before classification.
messageCount: integerrequired
socketOpened: booleanrequired
conversations: arrayrequired
conversations[].age: integer | string
conversations[].about: string
conversations[].gender: string
conversations[].chat_id: string
conversations[].user_id: string
conversations[].location: string
conversations[].screenname: string
conversations[].profile_tags: array
conversations[].profile_photo_icon: string
conversationCount: integerrequired
undecodableItemCount: integerrequired — Socket items this build could not read. Non-zero means the platform's frame shape has changed and this answer is INCOMPLETE - the account may hold conversations that are missing from the lists above.

Example request and response

The example response is generated from this operation’s published output schema — it shows the shape and field names, not values from a recorded call.

json — example request body

{
  "connectSid": "example",
  "maxSeconds": 12,
  "maxMessages": 300
}

json — example response shape

{
  "profile": {},
  "messages": [
    {
      "chatId": "example",
      "fromMe": false,
      "message": "example"
    }
  ],
  "elapsedMs": 1,
  "fetchedAt": "example",
  "frameCount": 1,
  "messageCount": 1,
  "socketOpened": false,
  "conversations": [
    {
      "age": 1,
      "about": "example",
      "gender": "example",
      "chat_id": "example",
      "user_id": "example",
      "location": "example",
      "screenname": "example",
      "profile_tags": [
        null
      ],
      "profile_photo_icon": "example"
    }
  ],
  "conversationCount": 1,
  "undecodableItemCount": 1
}

Code snippets

cURL

curl

curl -X POST https://api.upapi.io/chatous-get-account-state.get \
  -H 'Content-Type: application/json' \
  -H 'x-api-key: YOUR_API_KEY' \
  -d '{ "connectSid": "example", "maxSeconds": 12, "maxMessages": 300 }'

JavaScript

javascript

const response = await fetch('https://api.upapi.io/chatous-get-account-state.get', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'x-api-key': 'YOUR_API_KEY',
  },
  body: JSON.stringify({
  "connectSid": "example",
  "maxSeconds": 12,
  "maxMessages": 300
}),
});

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

Python

python

import requests

response = requests.post(
    'https://api.upapi.io/chatous-get-account-state.get',
    headers={
        'Content-Type': 'application/json',
        'x-api-key': 'YOUR_API_KEY',
    },
    json={
  "connectSid": "example",
  "maxSeconds": 12,
  "maxMessages": 300
},
)

print(response.json())

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
)

func main() {
	payload := []byte(`{ "connectSid": "example", "maxSeconds": 12, "maxMessages": 300 }`)

	req, _ := http.NewRequest("POST", "https://api.upapi.io/chatous-get-account-state.get", bytes.NewBuffer(payload))
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("x-api-key", "YOUR_API_KEY")

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	var result map[string]any
	json.Unmarshal(body, &result)
	fmt.Println(result)
}

PHP

php

<?php

$payload = json_encode([
    'connectSid' => 'example',
    'maxSeconds' => 12,
    'maxMessages' => 300,
]);

$ch = curl_init('https://api.upapi.io/chatous-get-account-state.get');
curl_setopt_array($ch, [
    CURLOPT_POST           => true,
    CURLOPT_POSTFIELDS     => $payload,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'Content-Type: application/json',
        'x-api-key: YOUR_API_KEY',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
var_dump($data);

Ruby

ruby

require 'net/http'
require 'uri'
require 'json'

uri = URI('https://api.upapi.io/chatous-get-account-state.get')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = uri.scheme == 'https'

request = Net::HTTP::Post.new(uri.path)
request['Content-Type'] = 'application/json'
request['x-api-key'] = 'YOUR_API_KEY'
request.body = { "connectSid": "example", "maxSeconds": 12, "maxMessages": 300 }.to_json

response = http.request(request)
puts JSON.parse(response.body)

Java

java

import okhttp3.*;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;

OkHttpClient client = new OkHttpClient();
ObjectMapper mapper = new ObjectMapper();

String json = "{ \"connectSid\": \"example\", \"maxSeconds\": 12, \"maxMessages\": 300 }";

RequestBody body = RequestBody.create(json, MediaType.get("application/json"));
Request request = new Request.Builder()
    .url("https://api.upapi.io/chatous-get-account-state.get")
    .post(body)
    .addHeader("Content-Type", "application/json")
    .addHeader("x-api-key", "YOUR_API_KEY")
    .build();

try (Response response = client.newCall(request).execute()) {
    Map<?, ?> result = mapper.readValue(response.body().string(), Map.class);
    System.out.println(result);
}

csharp

using System.Net.Http;
using System.Net.Http.Json;
using System.Text.Json;

using var client = new HttpClient();
client.DefaultRequestHeaders.Add("x-api-key", "YOUR_API_KEY");

var payload = JsonSerializer.Deserialize<object>("{ \"connectSid\": \"example\", \"maxSeconds\": 12, \"maxMessages\": 300 }");
var response = await client.PostAsJsonAsync("https://api.upapi.io/chatous-get-account-state.get", payload);

var result = await response.Content.ReadFromJsonAsync<JsonElement>();
Console.WriteLine(result);

Frequently asked questions

How much does the Chatous Get Account State API cost per call?

Each call spends 4 weighted units of your plan's monthly quota. Full pricing is at https://upapi.io/pricing.

How do I authenticate to the Chatous Get Account State API?

Send your key in the X-Api-Key header. A free guest key is available without creating an account.

Are Chatous Get Account State API responses cached?

No — every call runs the operation live; responses are not cached.

More Social Media APIs

Chatous Poll Events Chatous Check Session Get Bluesky Profile Get Contra Company Profile Get Mastodon Profile Instagram Get User By Id Instagram Get User Profile LinkedIn Get Profile

Browse every Social Media API →