SRO Filings Database API

import requests

url = "https://api.secfilingdata.com/v1/filings/sro/"

headers = {
    "Content-Type": "application/json",
    "Authorization": "AUTH_TOKEN"
}

payload = {
    "query_type": "srNumber",
    "query_value": "SR-TXSE-2025-003",
    "from": 0,
    "size": 10,
    "sort_order": "DESC"
}

response = requests.post(
    url,
    headers=headers,
    json=payload
)

print(response.json())

const url = "https://api.secfilingdata.com/v1/filings/sro/";

const payload = {
    query_type: "srNumber",
    query_value: "SR-TXSE-2025-003",
    from: 0,
    size: 10,
    sort_order: "DESC"
};

fetch(url, {
    method: "POST",
    headers: {
        "Content-Type": "application/json",
        "Authorization": "AUTH_TOKEN"
    },
    body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error(error));

const axios = require("axios");

const url = "https://api.secfilingdata.com/v1/filings/sro/";

const payload = {
    query_type: "srNumber",
    query_value: "SR-TXSE-2025-003",
    from: 0,
    size: 10,
    sort_order: "DESC"
};

axios.post(url, payload, {
    headers: {
        "Content-Type": "application/json",
        "Authorization": "AUTH_TOKEN"
    }
})
.then(response => {
    console.log(response.data);
})
.catch(error => {
    console.error(error);
});

curl --location 'https://api.secfilingdata.com/v1/filings/sro/' \
--header 'Content-Type: application/json' \
--header 'Authorization: AUTH_TOKEN' \
--data '{
    "query_type":"srNumber",
    "query_value":"SR-TXSE-2025-003",
    "from":0,
    "size":10,
    "sort_order":"DESC"
}'

package main

import (
    "bytes"
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {

    url := "https://api.secfilingdata.com/v1/filings/sro/"

    payload := []byte(`{
        "query_type":"srNumber",
        "query_value":"SR-TXSE-2025-003",
        "from":0,
        "size":10,
        "sort_order":"DESC"
    }`)

    req, _ := http.NewRequest(
        "POST",
        url,
        bytes.NewBuffer(payload),
    )

    req.Header.Set(
        "Content-Type",
        "application/json",
    )

    req.Header.Set(
        "Authorization",
        "AUTH_TOKEN",
    )

    client := &http.Client{}

    resp, err := client.Do(req)

    if err != nil {
        panic(err)
    }

    defer resp.Body.Close()

    body, _ := ioutil.ReadAll(resp.Body)

    fmt.Println(string(body))
}

import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Scanner;

public class Main {

    public static void main(String[] args)
    throws Exception {

        URL url = new URL(
            "https://api.secfilingdata.com/v1/filings/sro/"
        );

        HttpURLConnection conn =
            (HttpURLConnection) url.openConnection();

        conn.setRequestMethod("POST");

        conn.setRequestProperty(
            "Content-Type",
            "application/json"
        );

        conn.setRequestProperty(
            "Authorization",
            "AUTH_TOKEN"
        );

        conn.setDoOutput(true);

        String jsonInputString = "{"
                + "\"query_type\":\"srNumber\","
                + "\"query_value\":\"SR-TXSE-2025-003\","
                + "\"from\":0,"
                + "\"size\":10,"
                + "\"sort_order\":\"DESC\""
                + "}";

        try(OutputStream os =
                conn.getOutputStream()) {

            byte[] input =
                jsonInputString.getBytes("utf-8");

            os.write(input, 0, input.length);
        }

        Scanner scanner =
            new Scanner(conn.getInputStream());

        while(scanner.hasNext()) {

            System.out.println(
                scanner.nextLine()
            );
        }

        scanner.close();
    }
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var client = new HttpClient();

        client.DefaultRequestHeaders.Add(
            "Authorization",
            "AUTH_TOKEN"
        );

        var json = @"{
            ""query_type"": ""srNumber"",
            ""query_value"": ""SR-TXSE-2025-003"",
            ""from"": 0,
            ""size"": 10,
            ""sort_order"": ""DESC""
        }";

        var content = new StringContent(
            json,
            Encoding.UTF8,
            "application/json"
        );

        var response = await client.PostAsync(
            "https://api.secfilingdata.com/v1/filings/sro/",
            content
        );

        var result =
            await response.Content
            .ReadAsStringAsync();

        Console.WriteLine(result);
    }
}

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

url = URI(
  "https://api.secfilingdata.com/v1/filings/sro/"
)

http = Net::HTTP.new(
  url.host,
  url.port
)

http.use_ssl = true

request = Net::HTTP::Post.new(url)

request["Content-Type"] =
  "application/json"

request["Authorization"] =
  "AUTH_TOKEN"

request.body = {
  query_type: "srNumber",
  query_value: "SR-TXSE-2025-003",
  from: 0,
  size: 10,
  sort_order: "DESC"
}.to_json

response = http.request(request)

puts response.body

import requests

url = "https://api.secfilingdata.com/v1/filings/sro/metadata/all.json"
auth_token = "AUTH_TOKEN"

headers = {
    "Authorization": auth_token,
    "Accept": "application/json"
}

save_to = "sro-metadata-all.json"

with requests.get(url, headers=headers, stream=True) as r:
    if r.status_code != 200:
        raise Exception(f"Download failed: {r.status_code}")

    with open(save_to, "wb") as f:
        for chunk in r.iter_content(chunk_size=8192):
            if chunk:
                f.write(chunk)

print("Download complete")

const url = "https://api.secfilingdata.com/v1/filings/sro/metadata/all.json";
const authToken = "AUTH_TOKEN";

fetch(url, {
    method: "GET",
    headers: {
        "Authorization": authToken,
        "Accept": "application/json"
    }
})
.then(response => {
    if (!response.ok) {
        throw new Error("Download failed: " + response.status);
    }
    return response.blob();
})
.then(blob => {
    const link = document.createElement("a");
    link.href = window.URL.createObjectURL(blob);
    link.download = "sro-metadata-all.json";
    link.click();
})
.catch(err => console.error(err));

const fs = require("fs");
const https = require("https");

const url = "https://api.secfilingdata.com/v1/filings/sro/metadata/all.json";
const authToken = "AUTH_TOKEN";

const file = fs.createWriteStream("sro-metadata-all.json");

https.get(url, {
    headers: {
        "Authorization": authToken,
        "Accept": "application/json"
    }
}, (res) => {

    if (res.statusCode !== 200) {
        console.log("Download failed:", res.statusCode);
        res.resume();
        return;
    }

    res.pipe(file);

    file.on("finish", () => {
        file.close();
        console.log("Download complete");
    });

}).on("error", (err) => {
    fs.unlinkSync("sro-metadata-all.json");
    console.error(err.message);
});

curl -L \
  -H "Authorization: AUTH_TOKEN" \
  -H "Accept: application/json" \
  "https://api.secfilingdata.com/v1/filings/sro/metadata/all.json" \
  -o sro-metadata-all.json

package main

import (
    "io"
    "net/http"
    "os"
)

func main() {

    url := "https://api.secfilingdata.com/v1/filings/sro/metadata/all.json"
    authToken := "AUTH_TOKEN"

    client := &http.Client{}

    req, _ := http.NewRequest("GET", url, nil)
    req.Header.Add("Authorization", authToken)
    req.Header.Add("Accept", "application/json")

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

    if resp.StatusCode != 200 {
        panic(resp.Status)
    }

    out, err := os.Create("sro-metadata-all.json")
    if err != nil {
        panic(err)
    }
    defer out.Close()

    io.Copy(out, resp.Body)

    println("Download complete")
}

import java.io.*;
import java.net.*;

public class DownloadFile {
    public static void main(String[] args) throws Exception {

        String urlStr = "https://api.secfilingdata.com/v1/filings/sro/metadata/all.json";
        String authToken = "AUTH_TOKEN";

        URL url = new URL(urlStr);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();

        conn.setRequestMethod("GET");
        conn.setRequestProperty("Authorization", authToken);
        conn.setRequestProperty("Accept", "application/json");

        if (conn.getResponseCode() != 200) {
            System.out.println("Failed: " + conn.getResponseCode());
            return;
        }

        InputStream in = conn.getInputStream();
        FileOutputStream out = new FileOutputStream("sro-metadata-all.json");

        byte[] buffer = new byte[8192];
        int bytesRead;

        while ((bytesRead = in.read(buffer)) != -1) {
            out.write(buffer, 0, bytesRead);
        }

        out.close();
        in.close();

        System.out.println("Download complete");
    }
}

using System;
using System.Net.Http;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var url = "https://api.secfilingdata.com/v1/filings/sro/metadata/all.json";
        var authToken = "AUTH_TOKEN";

        using var client = new HttpClient();
        client.DefaultRequestHeaders.Add("Authorization", authToken);

        var response = await client.GetAsync(url);

        if (!response.IsSuccessStatusCode)
        {
            Console.WriteLine("Failed: " + response.StatusCode);
            return;
        }

        var stream = await response.Content.ReadAsStreamAsync();
        var file = File.Create("sro-metadata-all.json");

        await stream.CopyToAsync(file);

        file.Close();

        Console.WriteLine("Download complete");
    }
}

require 'net/http'
require 'uri'

url = URI("https://api.secfilingdata.com/v1/filings/sro/metadata/all.json")
auth_token = "AUTH_TOKEN"

Net::HTTP.start(url.host, url.port, use_ssl: true) do |http|

  request = Net::HTTP::Get.new(url)
  request["Authorization"] = auth_token
  request["Accept"] = "application/json"

  http.request(request) do |response|

    if response.code != "200"
      puts "Failed: #{response.code}"
      exit
    end

    File.open("sro-metadata-all.json", "w") do |file|
      response.read_body do |chunk|
        file.write(chunk)
      end
    end

    puts "Download complete"
  end
end