SLIP AMS Developer Documentation

Get Started with SLIP AMS

This resource is designed for developers and technical teams looking to integrate with the SLA system to submit and track insurance policies directly, programmatically, in real time.

SLIP AMS enables authorized brokers to electronically submit their policy information to the Surplus Line Association of California through a lightweight, developer-friendly web service. To get started, proceed to Step 1 to obtain API credentials.

🔑

1. Get API Credentials

Set up your SLIP account and obtain your broker number, username, and API key.

🔒

2. Authenticate

Exchange your credentials for a JWT Bearer token via the session's endpoint.

📋

3. Submit Policies

Post your JSON data and supporting documents to create and track submissions.

🔍

4. Track Submissions

Check submission status, view transactions, and inspect tag details in real time.

JWT Bearer Auth REST / JSON 7 Endpoints Prod + Train Envs

Environment

Switch between Production and Train environments using the toggle in the top bar. All code samples update automatically.

Base URL https://slip-api.slacal.com

Response format

All responses are application/json. Authenticated endpoints require a JWT Bearer token in the Authorization header. Tokens are obtained via POST /api/sessions. JWT tokens expire periodically — handle 401 Unauthorized responses by re-authenticating.

Postman CollectionAll 7 endpoints with pre-configured environments and example payloads.

Download

Getting Started/API Credentials & Account Setup

API Credentials & Account Setup

All authenticated SLIP AMS API requests require a JWT Bearer token. Obtain one by calling POST /api/sessions with your credentials.

To use the SLIP AMS API, you need a valid SLIP account with AMS API access enabled. Contact support@slacal.com if you do not yet have a SLIP account.

Setup Steps

1Log in to your SLIP account for your brokerage.

2Navigate to the Settings Tab, locate the AMS Token field. Note the SLABrokerNumber, Username, and AMS Token (API Key). If the field is empty, click “Regenerate AMS Token” to get a new API Key.

3Use these credentials in the POST /api/sessions call to obtain a JWT Bearer token for all subsequent requests.

4Pass the token in the Authorization header as Bearer <token> for every authenticated endpoint.

JWT tokens expire periodically. Your application should handle 401 Unauthorized responses by re-authenticating and retrying the request.

All authenticated endpoints

Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...

Sessions/Create Session

POST/api/sessions

Authenticates an AMS user and returns a JSON Web Token (JWT). Include this token as a Bearer token in the Authorization header of all subsequent authenticated requests.

Query Parameters

Parameter	Type	Status	Description
SLABrokerNumber	string	Required	Your SLAC broker number
Username	string	Required	Your SLIP AMS username
APIKey	string	Required	Your AMS Token (API Key) from SLIP Settings

Request

curl -X POST "{{BASE_URL}}/api/sessions?SLABrokerNumber=YOUR_BROKER_NUM&Username=YOUR_USER&APIKey=YOUR_API_KEY" \
  -H "accept: application/json" \
  -H "Content-Length: 0"

import urllib.request

url = "{{BASE_URL}}/api/sessions?SLABrokerNumber=YOUR_BROKER_NUM&Username=YOUR_USER&APIKey=YOUR_API_KEY"
req = urllib.request.Request(url, method="POST")
req.add_header("accept", "application/json")
req.add_header("Content-Length", "0")
urllib.request.urlopen(req)

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

class Program {
    static async Task Main() {
        using var client = new HttpClient();
        string url = "{{BASE_URL}}/api/sessions?SLABrokerNumber=YOUR_BROKER_NUM&Username=YOUR_USER&APIKey=YOUR_API_KEY";
        var request = new HttpRequestMessage(HttpMethod.Post, url);
        request.Headers.Add("accept", "application/json");
        request.Content = new StringContent(string.Empty);
        await client.SendAsync(request);
    }
}

import java.net.*;
import java.net.http.*;
import java.net.http.HttpResponse.*;

public class Main {
    public static void main(String[] args) throws Exception {
        String url = "{{BASE_URL}}/api/sessions?SLABrokerNumber=YOUR_BROKER_NUM&Username=YOUR_USER&APIKey=YOUR_API_KEY";
        HttpClient client = HttpClient.newBuilder().version(HttpClient.Version.HTTP_1_1).build();
        HttpRequest req = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("accept", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(""))
            .build();
        client.send(req, BodyHandlers.ofString());
    }
}

package main

import (
    "net/http"
    "strings"
)

func main() {
    url := "{{BASE_URL}}/api/sessions?SLABrokerNumber=YOUR_BROKER_NUM&Username=YOUR_USER&APIKey=YOUR_API_KEY"
    req, _ := http.NewRequest("POST", url, strings.NewReader(""))
    req.Header.Set("accept", "application/json")
    resp, _ := http.DefaultClient.Do(req)
    resp.Body.Close()
}

require 'net/http'
require 'uri'

url = URI("{{BASE_URL}}/api/sessions?SLABrokerNumber=YOUR_BROKER_NUM&Username=YOUR_USER&APIKey=YOUR_API_KEY")
Net::HTTP.post(url, "", {"accept" => "application/json"})

Response

200 OKAuthentication successful

{
  "Token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
}

401 UnauthorizedInvalid or missing JWT bearer token.

429 Too Many RequestsRate limit exceeded.

{
  "Error": "Rate limit exceeded",
  "limit": "per-minute"
}

500 Internal Server ErrorServer error

Submissions/Create Submission

POST/api/submissions

Submit a surplus lines policy to SLIP. The request body must be multipart/form-data containing the policy JSON and a supporting ZIP file with all required documents.

Requires Authorization: Bearer <token>. The policy JSON must conform to the submission schema available at GET /api/schema.

Request Body (multipart/form-data)

Parameter	Type	Status	Description
json	string	Required	JSON-encoded policy data (stringified)
file	file (ZIP)	Required	ZIP archive of all supporting policy documents
previewInSlip	boolean	Optional	Preview submission in SLIP before filing (default: false)
comments	string	Optional	Notes or comments for the submission

Request

curl -X POST "{{BASE_URL}}/api/submissions" \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -F "json={\"PolicyNumber\":\"POL-001\",\"InsuredName\":\"John Smith\"}" \
  -F "file=@policy_docs.zip"

import urllib.request, json

url      = "{{BASE_URL}}/api/submissions"
boundary = "----Boundary"

policy_json = json.dumps({"PolicyNumber": "POL-001", "InsuredName": "John Smith"})

body = (
    f'--{boundary}\r\nContent-Disposition: form-data; name="json"\r\n\r\n'
    f'{policy_json}\r\n'
    f'--{boundary}\r\nContent-Disposition: form-data; name="file"; filename="policy_docs.zip"\r\nContent-Type: application/zip\r\n\r\n'
).encode() + open("policy_docs.zip", "rb").read() + f'\r\n--{boundary}--\r\n'.encode()

req = urllib.request.Request(url, data=body)
req.add_header("Authorization", "Bearer YOUR_TOKEN")
req.add_header("Content-Type", f"multipart/form-data; boundary={boundary}")
urllib.request.urlopen(req)

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

class Program {
    static async Task Main() {
        using var client = new HttpClient();
        client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", "YOUR_TOKEN");
        var content = new MultipartFormDataContent();
        content.Add(new StringContent("{\"PolicyNumber\":\"POL-001\",\"InsuredName\":\"John Smith\"}"), "json");
        content.Add(new ByteArrayContent(File.ReadAllBytes("policy_docs.zip")), "file", "policy_docs.zip");
        await client.PostAsync("{{BASE_URL}}/api/submissions", content);
    }
}

import java.io.*;
import java.net.*;
import java.net.http.*;
import java.net.http.HttpResponse.*;
import java.nio.file.*;

public class Main {
    public static void main(String[] args) throws Exception {
        String boundary  = "----Boundary";
        String policyJson = "{\"PolicyNumber\":\"POL-001\",\"InsuredName\":\"John Smith\"}";
        byte[] zipData   = Files.readAllBytes(Paths.get("policy_docs.zip"));
        ByteArrayOutputStream buf = new ByteArrayOutputStream();
        buf.write(("--" + boundary + "\r\nContent-Disposition: form-data; name=\"json\"\r\n\r\n" + policyJson + "\r\n").getBytes());
        buf.write(("--" + boundary + "\r\nContent-Disposition: form-data; name=\"file\"; filename=\"policy_docs.zip\"\r\nContent-Type: application/zip\r\n\r\n").getBytes());
        buf.write(zipData);
        buf.write(("\r\n--" + boundary + "--\r\n").getBytes());
        HttpClient client = HttpClient.newBuilder().version(HttpClient.Version.HTTP_1_1).build();
        HttpRequest req = HttpRequest.newBuilder()
            .uri(URI.create("{{BASE_URL}}/api/submissions"))
            .header("Authorization", "Bearer YOUR_TOKEN")
            .header("Content-Type", "multipart/form-data; boundary=" + boundary)
            .POST(HttpRequest.BodyPublishers.ofByteArray(buf.toByteArray()))
            .build();
        client.send(req, BodyHandlers.ofString());
    }
}

package main

import (
    "bytes"
    "io"
    "mime/multipart"
    "net/http"
    "os"
)

func main() {
    var buf bytes.Buffer
    w := multipart.NewWriter(&buf)
    w.WriteField("json", `{"PolicyNumber":"POL-001","InsuredName":"John Smith"}`)
    fw, _ := w.CreateFormFile("file", "policy_docs.zip")
    f, _ := os.Open("policy_docs.zip")
    defer f.Close()
    io.Copy(fw, f)
    w.Close()
    req, _ := http.NewRequest("POST", "{{BASE_URL}}/api/submissions", &buf)
    req.Header.Set("Authorization", "Bearer YOUR_TOKEN")
    req.Header.Set("Content-Type", w.FormDataContentType())
    resp, _ := http.DefaultClient.Do(req)
    resp.Body.Close()
}

require 'net/http'
require 'uri'

uri  = URI("{{BASE_URL}}/api/submissions")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req  = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer YOUR_TOKEN"
req.set_form(
  [["json", '{"PolicyNumber":"POL-001","InsuredName":"John Smith"}'],
   ["file", File.open("policy_docs.zip"), { filename: "policy_docs.zip", content_type: "application/zip" }]],
  "multipart/form-data"
)
http.request(req)

Response

200 OKSubmission accepted

{
  "SubmissionNumber": "2026-02-17/001"
}

400 Bad RequestInvalid submission which returns a list of errors.

{
  "Errors": [
    "string"
  ]
}

401 UnauthorizedInvalid or missing JWT bearer token.

415 Unsupported Media TypeForm enctype not set to multipart/form-data.

429 Too Many RequestsRate limit exceeded.

{
  "Error": "Rate limit exceeded",
  "limit": "per-minute"
}

500 Internal Server ErrorServer error.

Schema/Submission Schema

GET/api/schema

Returns the JSON schema for the latest version of the SLIP AMS submission format. Use this to validate your policy JSON before submitting. No authentication required.

Request

curl "{{BASE_URL}}/api/schema"

import urllib.request, json

with urllib.request.urlopen("{{BASE_URL}}/api/schema") as resp:
    schema = json.loads(resp.read().decode())
    print(json.dumps(schema, indent=2))

using var client = new HttpClient();
string schema = await client.GetStringAsync("{{BASE_URL}}/api/schema");
Console.WriteLine(schema);

import java.net.*;
import java.net.http.*;
import java.net.http.HttpResponse.*;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest req = HttpRequest.newBuilder()
            .uri(URI.create("{{BASE_URL}}/api/schema"))
            .GET().build();
        HttpResponse<String> resp = client.send(req, BodyHandlers.ofString());
        System.out.println(resp.body());
    }
}

package main

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

func main() {
    resp, _ := http.Get("{{BASE_URL}}/api/schema")
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

require 'net/http'
require 'json'

res = Net::HTTP.get_response(URI("{{BASE_URL}}/api/schema"))
puts JSON.parse(res.body)

Response

200 OKSchema returned

{
  "$schema": "http://json-schema.org/draft/2020-12/schema",
  "$id": "https://slip-api.slacal.com/batch-submission/2.0/schema",
  "title": "SLIP AMS JSON Schema - Version 2-0. Last updated January 2024",
  "description": "This schema defines the data format for submitting batches to the SLIP system",
  "type": "object",
  "properties": {
    "Version": {
      "type": "string",
      "enum": ["2.0"]
    },
    "BatchDataSet": { ... }
  }
}

429 Too Many RequestsRate limit exceeded.

{
  "Error": "Rate limit exceeded",
  "limit": "per-minute"
}

500 Internal Server ErrorServer error.

Schema/Batch Schema

GET/batch-submission/{version}/schema

Returns the JSON schema for a specific version of the SLIP AMS batch submission format. No authentication required.

Path Parameters

Parameter	Type	Status	Description
version	string	Required	Schema version number (e.g. `1.1`, `2.0`)

Request

curl "{{BASE_URL}}/batch-submission/2.0/schema"

import urllib.request, json

with urllib.request.urlopen("{{BASE_URL}}/batch-submission/2.0/schema") as resp:
    schema = json.loads(resp.read().decode())
    print(json.dumps(schema, indent=2))

using var client = new HttpClient();
string schema = await client.GetStringAsync("{{BASE_URL}}/batch-submission/2.0/schema");
Console.WriteLine(schema);

import java.net.*;
import java.net.http.*;
import java.net.http.HttpResponse.*;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest req = HttpRequest.newBuilder()
            .uri(URI.create("{{BASE_URL}}/batch-submission/2.0/schema"))
            .GET().build();
        HttpResponse<String> resp = client.send(req, BodyHandlers.ofString());
        System.out.println(resp.body());
    }
}

package main

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

func main() {
    resp, _ := http.Get("{{BASE_URL}}/batch-submission/2.0/schema")
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

require 'net/http'
require 'json'

res = Net::HTTP.get_response(URI("{{BASE_URL}}/batch-submission/2.0/schema"))
puts JSON.parse(res.body)

Response

200 OKVersioned schema

{
  "$schema": "http://json-schema.org/draft/2020-12/schema",
  "$id": "https://slip-api.slacal.com/batch-submission/2.0/schema",
  "title": "SLIP AMS JSON Schema - Version 2-0. Last updated January 2024",
  "description": "This schema defines the data format for submitting batches to the SLIP system",
  "type": "object",
  "properties": {
    "Version": {
      "type": "string",
      "enum": ["2.0"]
    },
    "BatchDataSet": { ... }
  }
}

400 Bad RequestInvalid version requested.

Invalid version requested: 3.0

429 Too Many RequestsRate limit exceeded.

{
  "Error": "Rate limit exceeded",
  "limit": "per-minute"
}

500 Internal Server ErrorServer error.

Submissions/Submission Status

GET/api/submissions/{submissionNumber}

Retrieves the current status and summary details for a specific submission by its submission number. Requires JWT Bearer token.

Path Parameters

Parameter	Type	Status	Description
submissionNumber	string	Required	The submission number (e.g. `2026-02-17/001`)

Request

curl "{{BASE_URL}}/api/submissions/2026-02-17%2F001" \
  -H "Authorization: Bearer YOUR_TOKEN"

import urllib.request, json

url = "{{BASE_URL}}/api/submissions/2026-02-17/001"
req = urllib.request.Request(url)
req.add_header("Authorization", "Bearer YOUR_TOKEN")

with urllib.request.urlopen(req) as resp:
    data = json.loads(resp.read().decode())
    print(json.dumps(data, indent=2))

using var client = new HttpClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", "YOUR_TOKEN");
string result = await client.GetStringAsync("{{BASE_URL}}/api/submissions/2026-02-17/001");
Console.WriteLine(result);

import java.net.*;
import java.net.http.*;
import java.net.http.HttpResponse.*;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest req = HttpRequest.newBuilder()
            .uri(URI.create("{{BASE_URL}}/api/submissions/2026-02-17/001"))
            .header("Authorization", "Bearer YOUR_TOKEN")
            .GET().build();
        HttpResponse<String> resp = client.send(req, BodyHandlers.ofString());
        System.out.println(resp.body());
    }
}

package main

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

func main() {
    req, _ := http.NewRequest("GET", "{{BASE_URL}}/api/submissions/2026-02-17/001", nil)
    req.Header.Set("Authorization", "Bearer YOUR_TOKEN")
    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

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

uri = URI("{{BASE_URL}}/api/submissions/2026-02-17/001")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer YOUR_TOKEN"

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
puts JSON.parse(res.body)

Response

200 OKSubmission details

{
  "SubmissionNumber": "2026-03-23/0007",
  "Status": "Uploaded",
  "SubmissionErrors": [],
  "Notifications": []
}

401 UnauthorizedInvalid or missing JWT bearer token / Invalid user / Submission number not found for SLA Broker Number.

{
  "Errors": [
    "string"
  ]
}

429 Too Many RequestsRate limit exceeded.

{
  "Error": "Rate limit exceeded",
  "limit": "per-minute"
}

500 Internal Server ErrorServer error.

Submissions/Transactions

GET/api/submissions/{submissionNumber}/transactions

Returns a list of all policy transactions contained in the specified submission. Each transaction represents an individual policy line. Requires JWT Bearer token.

Path Parameters

Parameter	Type	Status	Description
submissionNumber	string	Required	The submission number (e.g. `2026-02-17/001`)

Request

curl "{{BASE_URL}}/api/submissions/2026-02-17%2F001/transactions" \
  -H "Authorization: Bearer YOUR_TOKEN"

import urllib.request, json

url = "{{BASE_URL}}/api/submissions/2026-02-17/001/transactions"
req = urllib.request.Request(url)
req.add_header("Authorization", "Bearer YOUR_TOKEN")

with urllib.request.urlopen(req) as resp:
    data = json.loads(resp.read().decode())
    print(json.dumps(data, indent=2))

using var client = new HttpClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", "YOUR_TOKEN");
string result = await client.GetStringAsync("{{BASE_URL}}/api/submissions/2026-02-17/001/transactions");
Console.WriteLine(result);

import java.net.*;
import java.net.http.*;
import java.net.http.HttpResponse.*;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest req = HttpRequest.newBuilder()
            .uri(URI.create("{{BASE_URL}}/api/submissions/2026-02-17/001/transactions"))
            .header("Authorization", "Bearer YOUR_TOKEN")
            .GET().build();
        HttpResponse<String> resp = client.send(req, BodyHandlers.ofString());
        System.out.println(resp.body());
    }
}

package main

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

func main() {
    req, _ := http.NewRequest("GET", "{{BASE_URL}}/api/submissions/2026-02-17/001/transactions", nil)
    req.Header.Set("Authorization", "Bearer YOUR_TOKEN")
    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

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

uri = URI("{{BASE_URL}}/api/submissions/2026-02-17/001/transactions")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer YOUR_TOKEN"

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
puts JSON.parse(res.body)

Response

200 OKSuccessful submission which returns list of transaction details.

{
  "Transactions": [
    {
      "TransactionID": 10000001,
      "PolicyNumber": "POL-001",
      "TransactionType": "NewBusiness",
      "Premium": 1354.95,
      "TaxableFees": 0.0,
      "InsuredName": "JOHN SMITH",
      "EndorsementNumber": null,
      "EffectiveDate": "2026-01-01T00:00:00",
      "Status": "Registered"
    },
    {
      "TransactionID": 10000002,
      "PolicyNumber": "POL-002",
      "TransactionType": "NewBusiness",
      "Premium": 2164.21,
      "TaxableFees": 0.0,
      "InsuredName": "JANE DOE",
      "EndorsementNumber": null,
      "EffectiveDate": "2026-01-02T00:00:00",
      "Status": "Registered"
    }
  ],
  "SubmissionNumber": "2026-02-17/001"
}

401 UnauthorizedInvalid or missing JWT bearer token / No transactions found for submission number and SLA Broker Number.

{
  "Errors": [
    "string"
  ]
}

429 Too Many RequestsRate limit exceeded.

{
  "Error": "Rate limit exceeded",
  "limit": "per-minute"
}

500 Internal Server ErrorServer error.

Submissions/Transaction Tags

GET/api/submissions/{submissionNumber}/transactions/tags

Returns all transactions for the specified submission, with full tag detail objects embedded in each transaction. Tags represent underwriting requirements, document requests, and other workflow items. Requires JWT Bearer token.

Path Parameters

Parameter	Type	Status	Description
submissionNumber	string	Required	The submission number (e.g. `2026-02-17/001`)

Request

curl "{{BASE_URL}}/api/submissions/2026-02-17%2F001/transactions/tags" \
  -H "Authorization: Bearer YOUR_TOKEN"

import urllib.request, json

url = "{{BASE_URL}}/api/submissions/2026-02-17/001/transactions/tags"
req = urllib.request.Request(url)
req.add_header("Authorization", "Bearer YOUR_TOKEN")

try:
    with urllib.request.urlopen(req) as resp:
        data = json.loads(resp.read().decode())
        print(json.dumps(data, indent=2))
except urllib.error.HTTPError as e:
    print(f"Error: {e.code} - {e.read().decode()}")

using var client = new HttpClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", "YOUR_TOKEN");
try {
    string result = await client.GetStringAsync("{{BASE_URL}}/api/submissions/2026-02-17/001/transactions/tags");
    Console.WriteLine(result);
} catch (Exception ex) {
    Console.WriteLine($"Error: {ex.Message}");
}

import java.net.*;
import java.net.http.*;
import java.net.http.HttpResponse.*;

public class Main {
    public static void main(String[] args) {
        try {
            HttpClient client = HttpClient.newHttpClient();
            HttpRequest req = HttpRequest.newBuilder()
                .uri(URI.create("{{BASE_URL}}/api/submissions/2026-02-17/001/transactions/tags"))
                .header("Authorization", "Bearer YOUR_TOKEN")
                .GET().build();
            HttpResponse<String> resp = client.send(req, BodyHandlers.ofString());
            System.out.println(resp.body());
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

package main

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

func main() {
    req, err := http.NewRequest("GET", "{{BASE_URL}}/api/submissions/2026-02-17/001/transactions/tags", nil)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    req.Header.Set("Authorization", "Bearer YOUR_TOKEN")
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

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

uri = URI("{{BASE_URL}}/api/submissions/2026-02-17/001/transactions/tags")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer YOUR_TOKEN"

begin
  res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
  if res.is_a?(Net::HTTPSuccess)
    puts JSON.parse(res.body)
  else
    puts "Error: #{res.code} - #{res.body}"
  end
rescue => e
  puts "Error: #{e.message}"
end

Response

200 OKSuccessful submission which returns list of transaction with tags details.

{
  "Transactions": [
    {
      "TagDetails": [
        {
          "TagNumber": "TAG-001",
          "TagCode": "DEC4",
          "TagType": "POLICY/CERTIFICATE NUMBER MISSING",
          "Category": "Standard",
          "TagGroup": "Dec Page",
          "TagText": "The policy number was not shown or is incomplete on the declaration page/binder/certificate.",
          "PreviousReplies": "string",
          "AssignedDate": "2026-01-01T00:00:00",
          "DueDate": "2026-01-01T00:00:00",
          "StatusCode": "Open",
          "Status": "Pending"
        }
      ],
      "TransactionID": 10000001,
      "PolicyNumber": "POL-001",
      "TransactionType": "NewBusiness",
      "Premium": 1354.95,
      "TaxableFees": 0.0,
      "InsuredName": "JOHN SMITH",
      "EndorsementNumber": null,
      "EffectiveDate": "2026-01-01T00:00:00",
      "Status": "Registered"
    }
  ],
  "SubmissionNumber": "2026-02-17/001"
}

401 UnauthorizedInvalid or missing JWT bearer token / No transactions found for submission number and SLA Broker Number.

{
  "Errors": [
    "string"
  ]
}

429 Too Many RequestsRate limit exceeded.

{
  "Error": "Rate limit exceeded",
  "limit": "per-minute"
}

500 Internal Server ErrorServer error.

Resources/Postman Collection

Postman Collection

Download the complete Postman collection with all 7 endpoints, pre-configured environments (Production & Train), and example payloads.

SLIP AMS API CollectionIncludes sessions, submissions, schema, transactions, and tags endpoints.

Download Collection

Import the collection into Postman and set the BASE_URL environment variable to https://slip-api.slacal.com (production) or https://slip-api.train.slacal.com (training).

Resources/Sample Data

Sample Data

The page contains sample JSON payloads and ZIP files with all required supporting documents, serving as a reference for data fields, structure, and documents needed to successfully submit a submission.

Master Policy

A master policy submission covers multiple certificate holders under a single policy, showing how to structure a policy of type Master with multiple insured certificate entries.
Use when the policy qualifies as a Master policy per SLA Guidelines.

JSON ZIP

Policy All Tabs

A comprehensive policy submission sample with every section populated - SL1, SL2, GAP form, layering, multi-state allocation, certificates, and transaction documents.
Use this as a reference for all available fields and their accepted formats.

JSON ZIP

Policy GAP

A new business policy submission that includes a GAP Exemption Placement Conditions/Requirements.
Use when the policy qualifies as a GAP placement per SLA Guidelines.

JSON ZIP

Policy Layering

A policy submission that contains multiple insurers, demonstrating how to structure multiple insurers sharing risk across coverage layers with percentage allocations.

JSON ZIP

Policy Multistate

A policy submission contains premium across multiple states, with California risk percentage and per-state allocation breakdowns.

JSON ZIP

Policy SL1

A new business policy submission including a completed SL1 (Confidential Report of Surplus Line Placement) online form with broker information, insured address, risk location, coverage codes, and a non-admitted insurer.
Use when the filer possesses the SL2 PDF form.

JSON ZIP

Policy SL2

A new business policy submission including an SL2 (Diligent Search Report) online form with broker information, insured address, risk location, and admitted insurer declination details.
Use when the filer possesses the SL1 PDF form.

JSON ZIP

Policy SL2 With Addendum

A new business policy submission with an SL2 online form that also includes an Addendum document, demonstrating how to attach supplemental disclosure paperwork alongside the standard form.
Use when the filer possesses the SL1 PDF form, and the policy requires an Addendum.

JSON ZIP

Download All Samples Downloads all JSON payloads and ZIP files as a single archive.

Resources/FAQ

Frequently Asked Questions

This section answers common questions about SLIP AMS submission development and procedure.

Getting Started

Where can I find technical documentation to help me access the “XML Data and Submit” to SLA option in SLIP?

The SLA intends to sunset the legacy XML-based submission method. We highly recommend that you transition to the JSON-based AMS submission, which is the current and supported method.

Why can’t our development team access the SLIP AMS API?

Access to SLIP AMS API is restricted by a geo-blocking policy that only permits connections from the United States and Canada.

If your development team is located outside of these two countries:

Complete the IP Whitelist Form
Email the completed form to support@slacal.com
The IP address(es) will be reviewed and whitelisted accordingly

Once I am satisfied with all my testing in the Train environment, what are the next steps to move to Production?

To move to Production, you must update all API configuration values:

Environment endpoint (SLIP Production URL)
SLA Broker Number (may differ between environments)
SLIP Username
AMS Token

Account & Access

Does it matter which SLIP user performs the API submission?

No. You may use any SLIP user (Master or Standard) as long as the user is associated with the brokerage location.

We recommend creating a dedicated user account (e.g. AMS_{BrokerName}) for AMS submissions. This allows:

Better visibility and tracking of submission successful/invalid emails
Easier account management if team members change

Why am I not receiving any submission emails?

Our Train environment does not send out any emails to avoid confusion with the Production environment.

To check submission status in Train, use the Submission Status API or Transaction Status calls.

Submission Rules & Requirements

Why is a ZIP file required if all data is in JSON?

A ZIP file is always required because one of the following documents must be included.

Minimum requirements:

New (N) or Renewal (R) transaction — Declaration Page
Endorsements (E, C, A, X) transaction — Endorsement document

An empty ZIP file will result in a submission error.

Do I need to submit a Coversheet?

No, submitting the Coversheet is optional. The system will automatically generate an online Coversheet using the submission data.

Do I need to submit D1 and/or D2 documents in my submission?

No, submitting D1/D2 documents is optional.

How many transactions per submission should I submit?

We recommend submitting up to 75 transactions per submission to ensure timely processing.

How often can I submit via the API?

We impose a daily limit of 200,000 requests.

Data Structure

If I include SL1 and/or SL2 data in JSON for submission, do I still need to attach the SL1 and/or SL2 document?

If SL1/SL2 data are included in the JSON, the SL1/SL2 document can be omitted.
If SL1/SL2 documents are included in the ZIP file, the SL1/SL2 data can be omitted from the payload.

Please refer to the Sample Data for correct payload structure:

Policy SL1
Policy SL2
Policy SL2 Addendum

When should I use the Master Policy payload?

Use the Master Policy payload only if the policy meets this definition:

A single contract issued to a group (e.g., employer, association)
Typically has no fixed expiration date
Individual members receive certificate of coverage

If your policy does not match this:

Do not use the Master Policy payload
Set IsMasterPolicy = false in all other payloads

Submission Errors & Troubleshooting

Error: “Could not find a part of the path …”

Cause: The system cannot locate the documents inside the ZIP file. A common issue is that documents are placed inside subfolders within the ZIP file.

Fix:

Do not use subfolders
Ensure all documents are in the root directory of the ZIP file

Error: “Object reference not set to an instance of an object”

Cause: Usually due to invalid or mismatched data, especially in the CoverageCode or NAICNumber field.

Fix:

Verify the coverage code matches the Coverage Code list, available on our Learning Center
Verify the NAIC Number of the insurer is valid
For Alien insurers, ensure the NAIC format contains the prefix AA- (e.g. AA-12345)

Technical Errors & Troubleshooting

How do I get a JWT Bearer token?

Send a POST /api/sessions request with your brokerNumber, username, and password. The response includes a token. Use it as Authorization: Bearer <token> on all subsequent requests.

Credentials are issued by SLACAL. If you don’t have an account yet, contact support@slacal.com.

My token expired. What do I do?

Tokens are time-limited. A 401 Unauthorized means yours has expired. Re-authenticate via POST /api/sessions and retry with the new token. In production, cache the token and refresh it before it expires rather than letting requests fail.

Why is my submission returning a 400 Bad Request?

The JSON in your ZIP doesn’t match the submission schema. Things to check:

Missing required fields: InsuredName, PolicyNumber, EffectiveDate.
Wrong date format — use YYYY-MM-DD.
The JSON file isn’t at the root of the ZIP, or filenames don’t match what the schema expects.
Content-Type isn’t set to multipart/form-data.

Pull the current schema from GET /api/schema or GET /batch-submission/{version}/schema and validate against it first.

What documents should I include in the ZIP file?

The ZIP must contain supporting policy documents. Use .pdf format for all supporting files.

Binder
Signed SL1
Signed SL2
Declarations page

See GET /batch-submission/{version}/schema for the full list of required and optional document types.

How do I check the status of my submission?

A successful POST /api/submissions returns a SubmissionNumber (e.g. 2024-10-11/1128). Pass it to any of these:

GET /api/submissions/{submissionNumber} — returns the overall submission status.
GET /api/submissions/{submissionNumber}/transactions — lists individual transactions and their state (Pending, Registered).
GET /api/submissions/{submissionNumber}/transactions/tags — returns tag details per transaction.

Limitations

How do I respond to transaction tags via the API?

You cannot respond to tags via the API. All tags must be handled manually within the SLIP website.

Can I submit non-premium bearing/nil endorsements or backouts through the API?

Nil endorsements and backouts are not supported by the API.

For instructions on how to submit a Nil endorsement, please visit our website.
The Change Request feature is available on SLIP for each transaction, allowing you to submit Backout requests.