REST APIs Guide

QlikElixir provides comprehensive coverage of Qlik Cloud REST APIs for managing your analytics infrastructure.

Overview

All REST API modules follow a consistent pattern:

# List resources with pagination
{:ok, %{"data" => items}} = Module.list(limit: 20, next: cursor)

# Get a single resource
{:ok, resource} = Module.get(id)

# Create a resource
{:ok, created} = Module.create(%{name: "New Resource"})

# Update a resource
{:ok, updated} = Module.update(id, %{name: "Updated Name"})

# Delete a resource
:ok = Module.delete(id)

Apps API

QlikElixir.REST.Apps | Qlik API Reference

Manage Qlik Sense applications - the core analytics containers.

alias QlikElixir.REST.Apps

# List apps
{:ok, %{"data" => apps}} = Apps.list(limit: 50, space_id: "space-123")

# Get app details
{:ok, app} = Apps.get("app-id")

# Create an app
{:ok, app} = Apps.create(%{name: "Sales Dashboard", space_id: "space-123"})

# Copy an app
{:ok, copy} = Apps.copy("app-id", name: "Dashboard Copy", space_id: "space-456")

# Publish to a managed space
{:ok, published} = Apps.publish("app-id", "managed-space-id")

# Export as .qvf binary
{:ok, binary} = Apps.export("app-id")
File.write!("app-backup.qvf", binary)

# Import from .qvf
binary = File.read!("app.qvf")
{:ok, imported} = Apps.import_app(binary, name: "Imported App")

# Get/validate load script
{:ok, %{"script" => script}} = Apps.get_script("app-id")
{:ok, validation} = Apps.validate_script(script)

# App metadata
{:ok, metadata} = Apps.get_metadata("app-id")
{:ok, lineage} = Apps.get_lineage("app-id")

# Media files
{:ok, media} = Apps.list_media("app-id")
{:ok, thumbnail} = Apps.get_thumbnail("app-id")

Spaces API

QlikElixir.REST.Spaces | Qlik API Reference

Manage shared and managed spaces for organizing content and controlling access.

alias QlikElixir.REST.Spaces

# List spaces
{:ok, %{"data" => spaces}} = Spaces.list(type: "shared")

# Create a shared space
{:ok, space} = Spaces.create(%{name: "Team Analytics", type: "shared"})

# Get space details
{:ok, space} = Spaces.get("space-id")

# Update space
{:ok, updated} = Spaces.update("space-id", %{name: "Updated Name"})

# Manage role assignments
{:ok, assignments} = Spaces.list_assignments("space-id")

{:ok, assignment} = Spaces.create_assignment("space-id", %{
  type: "user",
  assignee_id: "user-id",
  roles: ["consumer", "contributor"]
})

:ok = Spaces.delete_assignment("space-id", "assignment-id")

# List available space types
{:ok, types} = Spaces.list_types()

Data Files API

QlikElixir.REST.DataFiles | Qlik API Reference

Upload and manage data files used by apps.

alias QlikElixir.REST.DataFiles

# List files
{:ok, %{"data" => files}} = DataFiles.list(connection_id: "conn-123")

# Upload from file path
{:ok, file} = DataFiles.upload_file("sales.csv", overwrite: true)

# Upload binary content
csv = "id,name\n1,Alice\n2,Bob"
{:ok, file} = DataFiles.upload_content(csv, "users.csv")

# Get file details
{:ok, file} = DataFiles.get("file-id")

# Check if file exists
true = DataFiles.file_exists?("sales.csv")

# Find by name
{:ok, file} = DataFiles.find_file_by_name("sales.csv")

# Move to another space
{:ok, _} = DataFiles.change_space("file-id", "new-space-id")

# Batch operations
:ok = DataFiles.batch_delete(["file-1", "file-2", "file-3"])
:ok = DataFiles.batch_change_space(["file-1", "file-2"], "space-id")

# Check quotas
{:ok, quotas} = DataFiles.get_quotas()

Reloads API

QlikElixir.REST.Reloads | Qlik API Reference

Trigger and monitor app data reloads.

alias QlikElixir.REST.Reloads

# List recent reloads
{:ok, %{"data" => reloads}} = Reloads.list(app_id: "app-123")

# Trigger a reload
{:ok, reload} = Reloads.create("app-id", partial: false)

# Check status
{:ok, reload} = Reloads.get(reload["id"])
IO.puts("Status: #{reload["status"]}")  # QUEUED, RELOADING, SUCCEEDED, FAILED

# Cancel a running reload
:ok = Reloads.cancel(reload["id"])

# Poll until complete
defmodule ReloadHelper do
  def wait_for_reload(reload_id, timeout \\ 300_000) do
    start = System.monotonic_time(:millisecond)

    Stream.repeatedly(fn ->
      Process.sleep(5000)
      Reloads.get(reload_id)
    end)
    |> Stream.take_while(fn
      {:ok, %{"status" => status}} when status in ["QUEUED", "RELOADING"] ->
        System.monotonic_time(:millisecond) - start < timeout
      _ ->
        false
    end)
    |> Enum.to_list()
    |> List.last()
  end
end

Users API

QlikElixir.REST.Users | Qlik API Reference

Manage users in your Qlik Cloud tenant.

alias QlikElixir.REST.Users

# List users
{:ok, %{"data" => users}} = Users.list(limit: 100)

# Get current user
{:ok, me} = Users.me()

# Get user count
{:ok, %{"total" => count}} = Users.count()

# Get user by ID
{:ok, user} = Users.get("user-id")

# Filter users
{:ok, %{"data" => filtered}} = Users.filter("email eq 'user@example.com'")

# Invite users
{:ok, result} = Users.invite(["new@example.com", "another@example.com"])

# Create user
{:ok, user} = Users.create(%{
  name: "John Doe",
  email: "john@example.com",
  subject: "auth0|123456"
})

Automations API

QlikElixir.REST.Automations | Qlik API Reference

Create and manage no-code automation workflows.

alias QlikElixir.REST.Automations

# List automations
{:ok, %{"data" => autos}} = Automations.list(state: "enabled")

# Get automation details
{:ok, auto} = Automations.get("automation-id")

# Enable/disable
{:ok, _} = Automations.enable("automation-id")
{:ok, _} = Automations.disable("automation-id")

# Trigger a run
{:ok, run} = Automations.run("automation-id", inputs: %{"param1" => "value1"})

# List runs
{:ok, %{"data" => runs}} = Automations.list_runs("automation-id")

# Get run details
{:ok, run} = Automations.get_run("automation-id", "run-id")

# Stop or retry
:ok = Automations.stop_run("automation-id", "run-id")
{:ok, _} = Automations.retry_run("automation-id", "run-id")

# Usage statistics
{:ok, usage} = Automations.get_usage()

Webhooks API

QlikElixir.REST.Webhooks | Qlik API Reference

Configure event notifications.

alias QlikElixir.REST.Webhooks

# List webhooks
{:ok, %{"data" => hooks}} = Webhooks.list()

# Available event types
{:ok, types} = Webhooks.list_event_types()

# Create webhook
{:ok, hook} = Webhooks.create(%{
  name: "Reload Notifications",
  url: "https://api.example.com/webhooks/qlik",
  eventTypes: ["com.qlik.v1.reload.finished"],
  enabled: true
})

# Update webhook
{:ok, _} = Webhooks.update("webhook-id", %{enabled: false})

# View deliveries
{:ok, %{"data" => deliveries}} = Webhooks.list_deliveries("webhook-id")
{:ok, delivery} = Webhooks.get_delivery("webhook-id", "delivery-id")

# Retry failed delivery
{:ok, _} = Webhooks.resend_delivery("webhook-id", "delivery-id")

Data Connections API

QlikElixir.REST.DataConnections | Qlik API Reference

Manage external data source connections.

alias QlikElixir.REST.DataConnections

# List connections
{:ok, %{"data" => conns}} = DataConnections.list(space_id: "space-123")

# Create connection
{:ok, conn} = DataConnections.create(%{
  name: "Sales Database",
  type: "PostgreSQL",
  connectionString: "host=db.example.com;port=5432;database=sales"
})

# Duplicate connection
{:ok, copy} = DataConnections.duplicate("conn-id", name: "Sales DB Copy")

# Batch operations
:ok = DataConnections.batch_delete(["conn-1", "conn-2"])
{:ok, _} = DataConnections.batch_update([
  %{id: "conn-1", name: "Updated Name 1"},
  %{id: "conn-2", name: "Updated Name 2"}
])

Items API

QlikElixir.REST.Items | Qlik API Reference

Unified view of all content items (apps, data files, etc.).

alias QlikElixir.REST.Items

# List all items
{:ok, %{"data" => items}} = Items.list(resource_type: "app")

# Get item details
{:ok, item} = Items.get("item-id")

# Update item metadata
{:ok, _} = Items.update("item-id", %{name: "New Name"})

Collections API

QlikElixir.REST.Collections | Qlik API Reference

Organize content with collections.

alias QlikElixir.REST.Collections

# List collections
{:ok, %{"data" => colls}} = Collections.list()

# Create collection
{:ok, coll} = Collections.create(%{name: "Q4 Reports", type: "private"})

# Manage items
{:ok, items} = Collections.list_items("collection-id")
{:ok, _} = Collections.add_items("collection-id", ["item-1", "item-2"])
:ok = Collections.remove_item("collection-id", "item-1")

# Get user's favorites
{:ok, %{"data" => favorites}} = Collections.get_favorites()

Reporting API

QlikElixir.REST.Reports | Qlik API Reference

Reporting is asynchronous: you queue a request, poll its status, then collect the outputs. There is no listing of past reports — a request is a job, not a stored resource.

alias QlikElixir.REST.Reports

request = %{
  type: "sense-sheet-1.0",
  senseSheetTemplate: %{appId: "app-123", sheet: %{id: "sheet-456"}},
  output: %{
    type: "pdf",
    outputId: "monthly-sales",
    pdfOutput: %{size: "A4", orientation: "L", resizeType: "autofit"}
  },
  meta: %{outputTtl: "PT1H"}
}

# Queue, wait and collect in one call
{:ok, [output]} = Reports.generate(request)
{:ok, binary} = Reports.download_output(output)
File.write!("monthly-sales.pdf", binary)

# Or drive the three steps yourself
{:ok, %{"requestId" => id}} = Reports.create(request)
{:ok, %{"status" => "done"}} = Reports.await(id, timeout: :timer.minutes(10))
{:ok, %{"data" => outputs}} = Reports.list_outputs(id)

The output file lives in temporary content and expires with meta.outputTtl.

Report Templates API

QlikElixir.REST.ReportTemplates | Qlik API Reference

The stored Excel, Word or PowerPoint files that a report is rendered against.

alias QlikElixir.REST.ReportTemplates

{:ok, %{"data" => templates}} = ReportTemplates.list(name: "sales", sort: "-updatedAt")
{:ok, template} = ReportTemplates.get("template-123")
{:ok, xlsx} = ReportTemplates.download("template-123")

# Templates are created from a file already uploaded as temporary content
{:ok, created} = ReportTemplates.create(%{
  name: "Monthly Sales",
  source_app_id: "app-123",
  temporary_content_id: "653bb4acae966r0730da15fc"
})

Natural Language API

QlikElixir.REST.NaturalLanguage | Qlik API Reference

Conversational analytics with Insight Advisor.

alias QlikElixir.REST.NaturalLanguage

# Ask a natural language question
{:ok, result} = NaturalLanguage.ask("app-id", "What were total sales last quarter?")

# Get recommendations
{:ok, recommendations} = NaturalLanguage.get_recommendations("app-id")

Pagination

All list endpoints support cursor-based pagination:

# Manual pagination
{:ok, page1} = QlikElixir.REST.Apps.list(limit: 50)
cursor = page1["links"]["next"]["href"] |> extract_cursor()
{:ok, page2} = QlikElixir.REST.Apps.list(limit: 50, next: cursor)

# Stream all items
QlikElixir.Pagination.stream(fn cursor ->
  QlikElixir.REST.Apps.list(limit: 100, next: cursor)
end)
|> Enum.each(&process_app/1)

Additional APIs

Module	Description
`QlikElixir.REST.Groups`	User group management
`QlikElixir.REST.APIKeys`	API key management
`QlikElixir.REST.Tenants`	Tenant configuration
`QlikElixir.REST.Roles`	Role definitions
`QlikElixir.REST.Audits`	Audit event logging

Next Steps

QIX Engine Guide - Extract data from visualizations
Getting Started - Quick setup guide

← Previous Page Getting Started

Next Page → QIX Engine Guide