Saidit Getting Started: Account Creation and First API Call (2026)

Getting started overview

This guide outlines the initial steps for developers to begin working with Saidit's public API. Saidit is an open-source social media platform that emphasizes free speech and privacy. The platform provides a public API primarily for accessing content, such as posts and comments, and for performing actions that require user authentication. Unlike many commercial APIs, Saidit does not offer a dedicated developer portal, SDKs, or pre-generated API keys. Instead, developers interact directly with API endpoints using standard web protocols.

The process of getting started with Saidit's API involves creating a user account, understanding the authentication mechanism (which typically relies on session cookies or OAuth 2.0 for more complex applications), and then constructing HTTP requests to interact with the platform. This guide focuses on the fundamental steps: account creation, understanding how to authenticate, and making a simple, authenticated request to verify access.

Familiarity with RESTful API principles and HTTP requests is beneficial. For general information on how REST APIs function, refer to the MDN Web Docs on REST. Saidit's API documentation, while not a formal developer portal, is available within the platform's help section and provides details on available endpoints and expected parameters, which is essential for successful integration.

Create an account and get keys

Saidit's API access model is tied to user accounts. There are no standalone API keys or client secrets issued through a developer dashboard. Instead, API requests are typically authenticated either through a user's active session (via cookies) or using an OAuth 2.0 flow for applications that require broader permissions without direct user password handling. For basic getting started purposes, using a logged-in session is the most straightforward approach.

1. Register a Saidit account

Navigate to the Saidit registration page. You will need to choose a username and password. Saidit's emphasis on privacy means that email addresses are optional during registration, though providing one can assist with password recovery. Complete the CAPTCHA if prompted and agree to the terms of service to create your account.

2. Log in and establish a session

After registration, log into your new Saidit account via the Saidit login page. When you successfully log in through the web interface, Saidit sets a session cookie in your browser. This cookie contains authentication information, allowing subsequent requests from your browser to be recognized as authenticated. For API interactions, you will need to capture this session cookie and include it in your API requests. Tools like browser developer consoles or HTTP client extensions can assist in inspecting and extracting these cookies.

3. OAuth 2.0 for applications (optional advanced step)

For applications that need to act on behalf of users without storing their credentials, Saidit supports OAuth 2.0. This involves registering an application within your Saidit user settings (usually under "apps" or "developer settings" once logged in) to obtain a client ID and client secret. The OAuth 2.0 flow then allows users to grant your application specific permissions. The OAuth 2.0 specification provides a comprehensive overview of this authorization framework. For initial API testing, direct session authentication is simpler, but for production applications, OAuth 2.0 is recommended for security and user experience.

Your first request

Once you have a Saidit account and have established an authenticated session, you can make your first API request. This example demonstrates how to fetch information about the currently authenticated user.

Prerequisites:

• A Saidit account and an active logged-in session.
• A tool to make HTTP requests, such as curl, Postman, or a programming language's HTTP library.

Example: Fetching current user information

The endpoint /api/v1/user/me can be used to retrieve details about the authenticated user. This endpoint requires an authenticated request.

Using curl (with session cookie):

First, you need to obtain your Saidit session cookie. After logging into Saidit in your browser, open your browser's developer tools (usually F12). Navigate to the "Network" tab, refresh the page, and find a request to saidit.net. In the request headers, locate the Cookie header and copy its value. The primary cookie will typically be named session or similar.

Replace [YOUR_SESSION_COOKIE_VALUE] with the actual cookie string you copied.

curl -X GET \
  -H "Cookie: [YOUR_SESSION_COOKIE_VALUE]" \
  "https://saidit.net/api/v1/user/me"

A successful response will return JSON data about your user account, similar to this (truncated for brevity):

{
  "id": "t2_exampleid",
  "name": "your_username",
  "created_utc": 1609459200,
  "is_gold": false,
  "comment_karma": 10,
  "link_karma": 5,
  "has_verified_email": false,
  "is_mod": false,
  "is_admin": false,
  "verified": false,
  "hide_from_robots": false,
  "has_subscribed": true
  // ... more user data
}

If you receive an error, such as a 401 Unauthorized, it indicates an issue with your cookie or authentication. Ensure the cookie is current and correctly formatted.

Using Python requests library:

This example demonstrates how to achieve the same result programmatically using Python. Again, you will need to provide the session cookie.

import requests

# Replace with your actual session cookie value
session_cookie = "[YOUR_SESSION_COOKIE_VALUE]"

headers = {
    "Cookie": f"session={session_cookie}"
}

response = requests.get("https://saidit.net/api/v1/user/me", headers=headers)

if response.status_code == 200:
    print(response.json())
else:
    print(f"Error: {response.status_code} - {response.text}")

Common next steps

After successfully making your first authenticated request to Saidit's API, you can explore more advanced interactions:

1. Explore Saidit API Documentation: Refer to the Saidit help documentation for a comprehensive list of available API endpoints. This documentation details how to retrieve posts from specific subsaiddits, fetch comments, submit new content, and manage user settings. Understanding the available endpoints is crucial for building functional applications.

2. Implement OAuth 2.0: For applications that will be used by multiple users or require more secure authentication without handling user passwords directly, implement the OAuth 2.0 flow. This involves registering your application on Saidit and managing access tokens and refresh tokens. This is a standard practice for third-party integrations, as detailed in the IETF RFC 6749 for OAuth 2.0.

3. Content Retrieval: Practice fetching content from various subsaiddits. For example, you can retrieve the latest posts from /s/all or a specific community like /s/programming. Endpoints like /api/v1/r/[subsaiddit]/hot or /api/v1/r/[subsaiddit]/new are common starting points.

4. Content Submission: Once comfortable with retrieval, explore submitting posts or comments. This often involves sending POST requests with specific data payloads to endpoints such as /api/v1/submit for new posts or /api/v1/comment for comments.

5. Error Handling: Implement robust error handling in your application. The Saidit API will return standard HTTP status codes (e.g., 400 Bad Request, 403 Forbidden, 404 Not Found) along with JSON error messages. Proper error handling ensures your application can gracefully manage unexpected responses.

6. Rate Limiting: Be aware of potential rate limits. While Saidit's documentation may not explicitly detail strict rate limits, it's a common practice for APIs to limit the number of requests a client can make within a given timeframe to prevent abuse. Implement delays or backoff strategies if you encounter 429 Too Many Requests errors.

Troubleshooting the first call

Encountering issues during your first API call is common. Here are some troubleshooting steps:

• 401 Unauthorized Error: This is the most frequent issue. It indicates that your request was not properly authenticated. Double-check the following:

  • Cookie Validity: Ensure the session cookie you are using is still active and hasn't expired. Cookies typically have a limited lifespan.
  • Cookie Format: Verify that the Cookie header is correctly formatted (e.g., Cookie: session=[YOUR_SESSION_COOKIE_VALUE]).
  • Login Status: Confirm you are still logged into Saidit in your browser. If you log out, your session cookie becomes invalid.

• 403 Forbidden Error: This status code suggests that your authenticated user account does not have the necessary permissions to perform the requested action. For instance, trying to moderate a subsaiddit without being a moderator, or attempting to access private user data without explicit permission.

• 404 Not Found Error: This means the requested API endpoint or resource does not exist. Verify the URL of your API request against the Saidit API documentation to ensure it is correct.

• Network Issues: Ensure your internet connection is stable and that there are no firewalls or proxy settings blocking your HTTP requests to saidit.net.

• Incorrect HTTP Method: Ensure you are using the correct HTTP method (GET, POST, PUT, DELETE) for the specific endpoint. For example, fetching data typically uses GET, while submitting data uses POST.

• JSON Parsing Errors: If you receive a successful 200 OK response but cannot parse the data, verify that the response body is valid JSON. Sometimes, an API might return an HTML error page with a 200 status in specific edge cases, which would cause JSON parsing to fail.

• Consult Community/Docs: If issues persist, review the Saidit documentation thoroughly. As Saidit is open-source, community forums or the project's issue tracker may also provide insights into common problems and solutions.