Squid - No-Code ServiceNow Data Integration Hero banner for Squid documentation. Displays the tagline "Squid is Your No-Code ServiceNow Data Integration Tool"
with a decorative gradient accent bar on the left side. The design uses the arc46 brand purple (#5956FF) as the
primary accent color against a subtle off-white background.
Squid is Your
No-Code ServiceNow
Data Integration Tool
What does Squid do?
Squid exports data from ServiceNow as structured JSON — including references , relations , and nested entities — in a single API call. No scripting. No client-side assembly. Just configuration.
How Squid Works: From Request to Response This diagram illustrates how Squid processes a single HTTP request to return comprehensive, structured JSON data
from ServiceNow. The flow proceeds through four main stages:
STAGE 1 - HTTP REQUEST: The client sends a single HTTP GET request containing three key components:
- Configuration name (e.g., cmdb_ci_pc_hardware_full_inline) - determines which predefined or custom
configuration to use
- encodedQuery parameter - filters which records to retrieve (standard ServiceNow encoded query syntax)
- relations parameter (optional) - specifies which relations to resolve (e.g., used_by_service,
network_ports_inline)
STAGE 2 - CONFIGURATION: Squid loads the requested configuration which defines:
- Database View: Which ServiceNow view to query (controls available columns)
- Field Definitions: How each field should be rendered
- Reference RenderTypes: How to handle foreign key references (inline, reference, sys_id only, display_value)
- Relation Definitions: Available relations and how to render them
STAGE 3 - DATA PROCESSING: Squid performs three main operations:
- Query Execution: Retrieves base records from the database view using the encodedQuery filter
- Reference Resolution: For each reference field, follows the foreign key and retrieves the referenced entity.
This is recursive - referenced entities can have their own references that are also resolved. RenderTypes
determine whether references are embedded inline or collected in a separate 'referenced' section.
- Relation Resolution: For each requested relation, queries the related records. Supports CMDB relations
(parent/child via cmdb_rel_ci), 1-to-N relations, and M-to-N relations through junction tables.
STAGE 4 - JSON RESPONSE: A single structured JSON response containing:
- metadata: Request information, timing, configuration details
- data: Array of root entities with inline references fully resolved
- relations: Relations organized by root entity sys_id
- referenced: Entities referenced using 'reference' renderType (for deduplication)
KEY BENEFIT: What would require 11+ separate API calls with ServiceNow TableAPI (plus client-side logic to parse
links, extract sys_ids, and assemble the data) is accomplished with a single Squid request. All references are
recursively resolved, all relations are included, and the response is ready to use. HTTP Request
Single Request
/api/x_a46gh_squidx/v1/data/
cmdb_ci_pc_hardware_full_inline
? encodedQuery = base_name=w010y7 & relations = used_by_service,network_ports_inline Configuration Lookup
Database View
cmdb_ci_pc_hardware
columns + security filters
Field Definitions
name, asset_tag, ...
which fields to include
Reference Handling
inline, reference, sys_id
how to render FK links
Relation Definitions
used_by, network_ports
available relations
Data Processing
1
Query Execution
Retrieve base records from
database view with filter
base_name=w010y7
2
Reference Resolution
Follow foreign keys and
resolve referenced entities
Recursive: refs within refs
3
Relation Resolution
Query requested relations
CMDB, 1-to-N, M-to-N
used_by_service,
network_ports
Example: Resolved References
assigned_to →
sys_user (Rainer)
→ location →
cmn_location (Bern)
model_id →
cmdb_hardware_product_model
→ manufacturer →
core_company (Lenovo)
JSON Response
Complete Data
metadata
timing, config info
data[]
entities + inline refs
relations
by root sysId
referenced
external refs (dedupe)
Includes:
asset, assigned_to, location, manufacturer, model_id, used_by[], network_ports[]
+ nested:
assigned_to.location, model_id.manufacturer
SINGLE REQUEST
Why Squid?
ServiceNow's Table API returns raw table data without resolving references or relations. Getting complete, connected data requires multiple requests and custom logic on the consuming side.
Squid changes that.
Squid vs TableAPI Comparison This diagram compares how Squid and ServiceNow TableAPI handle the same data request: retrieving comprehensive laptop data with all related entities including asset, assigned_to, location, manufacturer, model, used_by services, and network ports.
SQUID (Left Panel - 1 Request):
Squid accomplishes this with a single HTTP GET request to /api/x_a46gh_squidx/v1/data/cmdb_ci_pc_hardware_full_inline with encodedQuery and relations parameters. The response includes all data in one JSON: asset, assigned_to, location, manufacturer, model_id, used_by[], network_ports[], plus nested references like assigned_to.location and model_id.manufacturer.
Advantages of Squid:
- Zero client-side logic required
- Recursive reference resolution
- Single network round-trip
- Pre-built configurations
TABLEAPI (Right Panel - 11 Requests):
ServiceNow TableAPI requires 11 separate requests plus client-side logic:
1. Initial Request to cmdb_ci_pc_hardware
2. Asset lookup to alm_hardware
3. Assigned To lookup to sys_user
4. User Location lookup to cmn_location
5. CI Location lookup to cmn_location
6. Manufacturer lookup to core_company
7. Model lookup to cmdb_model
8. Relations query to cmdb_rel_ci
9. Parent CI lookup to cmdb_ci
10. Service lookup to cmdb_ci_service_auto
11. Network Ports query to cmdb_ci_network_adapter
Challenges with TableAPI:
- Client must parse and extract links from each response
- Multiple network round-trips add latency
- Must know relation sys_ids in advance
- Manual table targeting required
BOTTOM LINE COMPARISON:
- Squid: 1 request, 0 client logic operations
- TableAPI: 11 requests, 10+ parse operations
Score: Squid:1 — TableAPI:11
Retrieving comprehensive laptop data with all related entities
1 Squid Single Request HTTP GET Request /api/.../data/cmdb_ci_pc_hardware_full_inline ?encodedQuery=...&relations=used_by,network_ports Complete JSON Response ✓ asset ✓ assigned_to ✓ location ✓ manufacturer ✓ model_id ✓ used_by ✓ network_ports ✓ user_location + Nested: assigned_to.location, model_id.manufacturer Advantages • Zero client-side logic • Recursive reference resolution • Single network round-trip • Pre-built configurations One request. All data. Zero complexity. 11 TableAPI Multiple Requests 1 Initial Request cmdb_ci_pc_hardware 2 Asset alm_hardware 3 Assigned To sys_user 4 User Location cmn_location 5 CI Location cmn_location 6 Manufacturer core_company 7 Model cmdb_model 8 Relations cmdb_rel_ci 9 Parent CI cmdb_ci 10 Service cmdb_ci_service_auto 11 Network Ports cmdb_ci_network_adapter Challenges • Parse and extract links • Multiple network round-trips • Must know relation sys_ids • Manual table targeting 1 Squid Requests 11 TableAPI Requests 0 Client Logic (Squid) 10+ Parse Ops (TableAPI) Where TableAPI needs 11 requests plus client logic, Squid delivers the same data in 1 request — fully resolved and ready to use.
See the detailed comparison →
What's in these docs?
Section What you'll find Give it a Spin Try Squid with demo data or your own non-prod instance Install Squid Production deployment guide API Reference Request format, parameters, filtering, relations Configurations 100+ predefined configs for common ServiceNow tables Security Authentication, authorization, ACLs, data access controls FAQs Common questions answered
Quick start
Ready to integrate?
Give it a spin — try with demo data or your dev instanceInstall Squid — production deployment guide
Evaluating Squid?