Integrations for Devs

Rafael Fernandes — Wed, 10 Sep 2025 15:09:03 GMT

Current Revision posted to Dev Tutorials by Rafael Fernandes on 9/10/2025 3:09:03 PM

Integration Approaches

The Sugar platform is extremely powerful, flexible, and allows for easy integration. This flexibility means that determining the best approach for your use case scenario is the key to success.

Push/Pull from Sugar via REST API
- Recommended approach
- Developers have full control over integration
- Integration can be stopped and systems will continue to work
- Retry mechanism: Resume integrations at any time (identify deltas through "last_update_time" flags)
- The time delay from/to Sugar is minimal
- Sugar REST API offers almost everything you need, and can be further extended via customization
Push to Sugar, Sugar pushes to an external queue in realtime
- Use Sugar Events to trigger through Logic Hooks
- Requires Logic Hooks (code customization) to be created and deployed
- Does not offer a "retry mechanism", if a logic hook fails to deliver to a queue or contact an external system
- Synchronous in nature, requires a response from an external system
- Needs to handle dependencies manually (contact can only be created after account)
- Good to have a middleware/queue in front of Sugar to receive those event triggers to reliably manage peak loads
Realtime: Embed your app into Sugar through Dashlets
- Simplest approach
- Often requires web user-based authentication
- All load/traffic goes directly to your system, which makes your system the performance bottleneck

REST API Webservices

Accessing your data when you want is good. Accessing your data however you want is better. When you decide to build an integration with Sugar, you’ll need an easy way to access and interact with the data stored in Sugar. The REST (representational state transfer) API (application programming interface) is perfect for this.

You can also leverage our live Sugar RESTful API Collection

Sugar REST API Overview
- Fully RESTfull (GET, POST, PUT, DELETE)
- OAuth2 token based
- All fields and modules are available through the API automatically
- Metadata API provides everything you need to know about your Sugar instance.

Topics

Common APIs

It is important to understand our most commonly used APIs and their functions within Sugar. Your integration might need data within Sugar's module structure that could potentially change over time, so you can use Metadata for it as well as CRUD onto Sugar.

Metadata
- Endpoint with current system's structure
- Modules, fields, relationships, layouts
- Use carefully, its payload can be MBs in size, cache as much as possible
- GET /metadata (use filters as much as possible)
- It does not retrieve labels for dropdowns, use language API to do so
- 3 Tips for using the Sugar Metadata API
Language
- Endpoint to retrieve labels
- Dropdown list values
- Any language-specific content
- GET /lang/<language_code>
CRUD (Create, Read, Update, Delete) records
- Read: GET /<module>/:record
- Create: POST /<module>
- Update: PUT /<module>/:record
- Delete: DELETE /<module>/:record
- Filter: POST /<module>/filter
  - You can use GET as well
  - POST solves the issue when a query is too long and hits HTTP limits
- Retrieve records related to another module: GET /<module>/:record/link/:link_name
- Creates a relationship to a pre-existing record: POST /<module>/:record/link/:link_name/:remote_id

Performance and Best Practices

As you deep dive into Sugar APIs, you will see how easy it is to integrate to pull and push data from and to Sugar and your systems, however, you must consider performance so your integration doesn't become a bottleneck between those systems.

You should consider the following guidelines when implementing your integrations:

Use Sugar's sync_key to link to remote IDs
- Sugar provides in every module a sync_key field
- sync_key is a unique identifier for that module that links back to your external system's generated key
- For example, account ID from ERP is AC0001, set sync_key (pass as a parameter in the POST) and sugar will create a record in account with sync_key=AC0001
- Next patch/update, sugar will check "where sync_key='AC0001'" and update it (it is indexed)
Use Sugar Integrate Upsert APIs
- Sugar's "update or insert" API based on sync_key
- Simplifies a common operation - if record exists, update it, otherwise create it (GET followed by a PUT or POST)
- Upsert by sync_key
- Get by sync_key
- Delete by sync_key
- Set a sync on existing record (without sync_key)
- Create relationship based on sync_key
- Delete relationship based on sync_key
- Note: This endpoint is engineered for maximum performance and omits several ACL and validation checks.
- Important: For security reasons, the Upsert API is restricted to Admin users only—non-admin users will be denied access.
Use Sugar Bulk API
- An endpoint that encapsulates multiple API calls into one single HTTP request
- Requests are executed synchronously (one after the other)
- Reducing network latency between calls
- Combined with Upsert provides the best performance
- Careful not to add too many requests to it
- Start small (5 to 10 requests) and increase until you reach its max capacity
Polling and filtering time-based with Filter API
- Integration gateway (or your external system) asks Sugar every X minutes
- Request Filter API using max_num (max number of records), offset and fields
- The response will provide the data as well as next_offset (offset can be seen as pagination)
- if next_offset is -1, no more records to go through
Initial Data Load into Sugar
- Use Bulk + Upsert to achieve data loads
- Millions of records may take a little while to process, plan ahead (over the weekend)
- Use multi-thread processes to load (for example 20 threads sending 20 bulk upsert requests)
- Careful with Sugar Cloud rate limits
- It's always a good idea to let Sugar Support know you're data loading, they will be considerate.
Understanding PHP limitations
- PHP is single-threaded with limited resources to process your request
- If you send too much data using bulk, you may run out of memory for that request
- Push to the limits but give some room for PHP to finish the request gracefully
Pagination for millions of records by using OFFSET will degrade performance
- We rely on DB to find, sort and limit records
- Nice article explaining how this works in details
- Instead of offsets, store the last processed ID and use it in the WHERE clause and sort by ID
- Example
  - Instead of: (/v11_25/Leads?max_num=1000&offset=4619000&order_by=id)
  - Do this (/v11_25/Leads?filter=[{"id": {"$gt": ”<last_id>"}}]&max_num=1000&order_by=id)
- If you need to add a date, make sure to add it as part of the filter and order

You're up and running, but don't stop now - this is just the beginning of your journey. Now it's time to Customizations.

Integrations for Devs

Rafael Fernandes — Thu, 14 Aug 2025 17:27:02 GMT

Revision 28 posted to Dev Tutorials by Rafael Fernandes on 8/14/2025 5:27:02 PM

Integration Approaches

The Sugar platform is extremely powerful, flexible, and allows for easy integration. This flexibility means that determining the best approach for your use case scenario is the key to success.

Push/Pull from Sugar via REST API
- Recommended approach
- Developers have full control over integration
- Integration can be stopped and systems will continue to work
- Retry mechanism: Resume integrations at any time (identify deltas through "last_update_time" flags)
- The time delay from/to Sugar is minimal
- Sugar REST API offers almost everything you need, and can be further extended via customization
Push to Sugar, Sugar pushes to an external queue in realtime
- Use Sugar Events to trigger through Logic Hooks
- Requires Logic Hooks (code customization) to be created and deployed
- Does not offer a "retry mechanism", if a logic hook fails to deliver to a queue or contact an external system
- Synchronous in nature, requires a response from an external system
- Needs to handle dependencies manually (contact can only be created after account)
- Good to have a middleware/queue in front of Sugar to receive those event triggers to reliably manage peak loads
Realtime: Embed your app into Sugar through Dashlets
- Simplest approach
- Often requires web user-based authentication
- All load/traffic goes directly to your system, which makes your system the performance bottleneck

REST API Webservices

You can also leverage our live Sugar RESTful API Collection

Sugar REST API Overview
- Fully RESTfull (GET, POST, PUT, DELETE)
- OAuth2 token based
- All fields and modules are available through the API automatically
- Metadata API provides everything you need to know about your Sugar instance.

Topics

Common APIs

Metadata
- Endpoint with current system's structure
- Modules, fields, relationships, layouts
- Use carefully, its payload can be MBs in size, cache as much as possible
- GET /metadata (use filters as much as possible)
- It does not retrieve labels for dropdowns, use language API to do so
- 3 Tips for using the Sugar Metadata API
Language
- Endpoint to retrieve labels
- Dropdown list values
- Any language-specific content
- GET /lang/<language_code>
CRUD (Create, Read, Update, Delete) records
- Read: GET /<module>/:record
- Create: POST /<module>
- Update: PUT /<module>/:record
- Delete: DELETE /<module>/:record
- Filter: POST /<module>/filter
  - You can use GET as well
  - POST solves the issue when a query is too long and hits HTTP limits
- Retrieve records related to another module: GET /<module>/:record/link/:link_name
- Creates a relationship to a pre-existing record: POST /<module>/:record/link/:link_name/:remote_id

Performance and Best Practices

You should consider the following guidelines when implementing your integrations:

Use Sugar's sync_key to link to remote IDs
- Sugar provides in every module a sync_key field
- sync_key is a unique identifier for that module that links back to your external system's generated key
- For example, account ID from ERP is AC0001, set sync_key (pass as a parameter in the POST) and sugar will create a record in account with sync_key=AC0001
- Next patch/update, sugar will check "where sync_key='AC0001'" and update it (it is indexed)
Use Sugar Integrate Upsert APIs
- Sugar's "update or insert" API based on sync_key
- Simplifies a common operation - if record exists, update it, otherwise create it (GET followed by a PUT or POST)
- Upsert by sync_key
- Get by sync_key
- Delete by sync_key
- Set a sync on existing record (without sync_key)
- Create relationship based on sync_key
- Delete relationship based on sync_key
Use Sugar Bulk API
- An endpoint that encapsulates multiple API calls into one single HTTP request
- Requests are executed synchronously (one after the other)
- Reducing network latency between calls
- Combined with Upsert provides the best performance
- Careful not to add too many requests to it
- Start small (5 to 10 requests) and increase until you reach its max capacity
Polling and filtering time-based with Filter API
- Integration gateway (or your external system) asks Sugar every X minutes
- Request Filter API using max_num (max number of records), offset and fields
- The response will provide the data as well as next_offset (offset can be seen as pagination)
- if next_offset is -1, no more records to go through
Initial Data Load into Sugar
- Use Bulk + Upsert to achieve data loads
- Millions of records may take a little while to process, plan ahead (over the weekend)
- Use multi-thread processes to load (for example 20 threads sending 20 bulk upsert requests)
- Careful with Sugar Cloud rate limits
- It's always a good idea to let Sugar Support know you're data loading, they will be considerate.
Understanding PHP limitations
- PHP is single-threaded with limited resources to process your request
- If you send too much data using bulk, you may run out of memory for that request
- Push to the limits but give some room for PHP to finish the request gracefully
Pagination for millions of records by using OFFSET will degrade performance
- We rely on DB to find, sort and limit records
- Nice article explaining how this works in details
- Instead of offsets, store the last processed ID and use it in the WHERE clause and sort by ID
- Example
  - Instead of: (/v11_25/Leads?max_num=1000&offset=4619000&order_by=id)
  - Do this (/v11_25/Leads?filter=[{"id": {"$gt": ”<last_id>"}}]&max_num=1000&order_by=id)
- If you need to add a date, make sure to add it as part of the filter and order

You're up and running, but don't stop now - this is just the beginning of your journey. Now it's time to Customizations.

Integrations for Devs

Rafael Fernandes — Fri, 16 May 2025 14:49:22 GMT

Revision 27 posted to Dev Tutorials by Rafael Fernandes on 5/16/2025 2:49:22 PM

Integration Approaches

The Sugar platform is extremely powerful, flexible, and allows for easy integration. This flexibility means that determining the best approach for your use case scenario is the key to success.

Push/Pull from Sugar via REST API
- Recommended approach
- Developers have full control over integration
- Integration can be stopped and systems will continue to work
- Retry mechanism: Resume integrations at any time (identify deltas through "last_update_time" flags)
- The time delay from/to Sugar is minimal
- Sugar REST API offers almost everything you need, and can be further extended via customization
Push to Sugar, Sugar pushes to an external queue in realtime
- Use Sugar Events to trigger through Logic Hooks
- Requires Logic Hooks (code customization) to be created and deployed
- Does not offer a "retry mechanism", if a logic hook fails to deliver to a queue or contact an external system
- Synchronous in nature, requires a response from an external system
- Needs to handle dependencies manually (contact can only be created after account)
- Good to have a middleware/queue in front of Sugar to receive those event triggers to reliably manage peak loads
Realtime: Embed your app into Sugar through Dashlets
- Simplest approach
- Often requires web user-based authentication
- All load/traffic goes directly to your system, which makes your system the performance bottleneck

REST API Webservices

Sugar REST API Overview
- Fully RESTfull (GET, POST, PUT, DELETE)
- OAuth2 token based
- All fields and modules are available through the API automatically
- Metadata API provides everything you need to know about your Sugar instance.

Topics

Common APIs

Metadata
- Endpoint with current system's structure
- Modules, fields, relationships, layouts
- Use carefully, its payload can be MBs in size, cache as much as possible
- GET /metadata (use filters as much as possible)
- It does not retrieve labels for dropdowns, use language API to do so
- 3 Tips for using the Sugar Metadata API
Language
- Endpoint to retrieve labels
- Dropdown list values
- Any language-specific content
- GET /lang/<language_code>
CRUD (Create, Read, Update, Delete) records
- Read: GET /<module>/:record
- Create: POST /<module>
- Update: PUT /<module>/:record
- Delete: DELETE /<module>/:record
- Filter: POST /<module>/filter
  - You can use GET as well
  - POST solves the issue when a query is too long and hits HTTP limits
- Retrieve records related to another module: GET /<module>/:record/link/:link_name
- Creates a relationship to a pre-existing record: POST /<module>/:record/link/:link_name/:remote_id

Performance and Best Practices

You should consider the following guidelines when implementing your integrations:

Use Sugar's sync_key to link to remote IDs
- Sugar provides in every module a sync_key field
- sync_key is a unique identifier for that module that links back to your external system's generated key
- For example, account ID from ERP is AC0001, set sync_key (pass as a parameter in the POST) and sugar will create a record in account with sync_key=AC0001
- Next patch/update, sugar will check "where sync_key='AC0001'" and update it (it is indexed)
Use Sugar Integrate Upsert APIs
- Sugar's "update or insert" API based on sync_key
- Simplifies a common operation - if record exists, update it, otherwise create it (GET followed by a PUT or POST)
- Upsert by sync_key
- Get by sync_key
- Delete by sync_key
- Set a sync on existing record (without sync_key)
- Create relationship based on sync_key
- Delete relationship based on sync_key
Use Sugar Bulk API
- An endpoint that encapsulates multiple API calls into one single HTTP request
- Requests are executed synchronously (one after the other)
- Reducing network latency between calls
- Combined with Upsert provides the best performance
- Careful not to add too many requests to it
- Start small (5 to 10 requests) and increase until you reach its max capacity
Polling and filtering time-based with Filter API
- Integration gateway (or your external system) asks Sugar every X minutes
- Request Filter API using max_num (max number of records), offset and fields
- The response will provide the data as well as next_offset (offset can be seen as pagination)
- if next_offset is -1, no more records to go through
Initial Data Load into Sugar
- Use Bulk + Upsert to achieve data loads
- Millions of records may take a little while to process, plan ahead (over the weekend)
- Use multi-thread processes to load (for example 20 threads sending 20 bulk upsert requests)
- Careful with Sugar Cloud rate limits
- It's always a good idea to let Sugar Support know you're data loading, they will be considerate.
Understanding PHP limitations
- PHP is single-threaded with limited resources to process your request
- If you send too much data using bulk, you may run out of memory for that request
- Push to the limits but give some room for PHP to finish the request gracefully
Pagination for millions of records by using OFFSET will degrade performance
- We rely on DB to find, sort and limit records
- Nice article explaining how this works in details
- Instead of offsets, store the last processed ID and use it in the WHERE clause and sort by ID
- Example
  - Instead of: (/v11_25/Leads?max_num=1000&offset=4619000&order_by=id)
  - Do this (/v11_25/Leads?filter=[{"id": {"$gt": ”<last_id>"}}]&max_num=1000&order_by=id)
- If you need to add a date, make sure to add it as part of the filter and order

You're up and running, but don't stop now - this is just the beginning of your journey. Now it's time to Customizations.

Integrations for Devs

Rafael Fernandes — Thu, 22 Aug 2024 14:58:38 GMT

Revision 26 posted to Dev Tutorials by Rafael Fernandes on 8/22/2024 2:58:38 PM

Integration Approaches

The Sugar platform is extremely powerful, flexible, and allows for easy integration. This flexibility means that determining the best approach for your use case scenario is the key to success.

Push/Pull from Sugar via REST API
- Recommended approach
- Developers have full control over integration
- Integration can be stopped and systems will continue to work
- Retry mechanism: Resume integrations at any time (identify deltas through "last_update_time" flags)
- The time delay from/to Sugar is minimal
- Sugar REST API offers almost everything you need, and can be further extended via customization
Push to Sugar, Sugar pushes to an external queue in realtime
- Use Sugar Events to trigger through Logic Hooks
- Requires Logic Hooks (code customization) to be created and deployed
- Does not offer a "retry mechanism", if a logic hook fails to deliver to a queue or contact an external system
- Synchronous in nature, requires a response from an external system
- Needs to handle dependencies manually (contact can only be created after account)
- Good to have a middleware/queue in front of Sugar to receive those event triggers to reliably manage peak loads
Realtime: Embed your app into Sugar through Dashlets
- Simplest approach
- Often requires web user-based authentication
- All load/traffic goes directly to your system, which makes your system the performance bottleneck

REST API Webservices

Sugar REST API Overview
- Fully RESTfull (GET, POST, PUT, DELETE)
- OAuth2 token based
- All fields and modules are available through the API automatically
- Metadata API provides everything you need to know about your Sugar instance.

Topics

Common APIs

Metadata
- Endpoint with current system's structure
- Modules, fields, relationships, layouts
- Use carefully, its payload can be MBs in size, cache as much as possible
- GET /metadata (use filters as much as possible)
- It does not retrieve labels for dropdowns, use language API to do so
- 3 Tips for using the Sugar Metadata API
Language
- Endpoint to retrieve labels
- Dropdown list values
- Any language-specific content
- GET /lang/<language_code>
CRUD (Create, Read, Update, Delete) records
- Read: GET /<module>/:record
- Create: POST /<module>
- Update: PUT /<module>/:record
- Delete: DELETE /<module>/:record
- Filter: POST /<module>/filter
  - You can use GET as well
  - POST solves the issue when a query is too long and hits HTTP limits
- Retrieve records related to another module: GET /<module>/:record/link/:link_name
- Creates a relationship to a pre-existing record: POST /<module>/:record/link/:link_name/:remote_id

Performance and Best Practices

You should consider the following guidelines when implementing your integrations:

Use Sugar's sync_key to link to remote IDs
- Sugar provides in every module a sync_key field
- sync_key is a unique identifier for that module that links back to your external system's generated key
- For example, account ID from ERP is AC0001, set sync_key (pass as a parameter in the POST) and sugar will create a record in account with sync_key=AC0001
- Next patch/update, sugar will check "where sync_key='AC0001'" and update it (it is indexed)
Use Sugar Integrate Upsert APIs
- Sugar's "update or insert" API based on sync_key
- Simplifies a common operation - if record exists, update it, otherwise create it (GET followed by a PUT or POST)
- Upsert by sync_key
- Get by sync_key
- Delete by sync_key
- Set a sync on existing record (without sync_key)
- Create relationship based on sync_key
- Delete relationship based on sync_key
Use Sugar Bulk API
- An endpoint that encapsulates multiple API calls into one single HTTP request
- Requests are executed synchronously (one after the other)
- Reducing network latency between calls
- Combined with Upsert provides the best performance
- Careful not to add too many requests to it
- Start small (5 to 10 requests) and increase until you reach its max capacity
Polling and filtering time-based with Filter API
- Integration gateway (or your external system) asks Sugar every X minutes
- Request Filter API using max_num (max number of records), offset and fields
- The response will provide the data as well as next_offset (offset can be seen as pagination)
- if next_offset is -1, no more records to go through
Initial Data Load into Sugar
- Use Bulk + Upsert to achieve data loads
- Millions of records may take a little while to process, plan ahead (over the weekend)
- Use multi-thread processes to load (for example 20 threads sending 20 bulk upsert requests)
- Careful with Sugar Cloud rate limits
- It's always a good idea to let Sugar Support know you're data loading, they will be considerate.
Understanding PHP limitations
- PHP is single-threaded with limited resources to process your request
- If you send too much data using bulk, you may run out of memory for that request
- Push to the limits but give some room for PHP to finish the request gracefully
Pagination for millions of records by using OFFSET will degrade performance
- We rely on DB to find, sort and limit records
- Nice article explaining how this works in details
- Instead of offsets, store the last processed ID and use it in the WHERE clause and sort by ID
- Example
  - Instead of: (/v11_25/Leads?max_num=1000&offset=4619000&order_by=id)
  - Do this (/v11_25/Leads?filter=[{"id":”<last_id>"}]&max_num=1000&order_by=id)
- If you need to add a date, make sure to add it as part of the filter and order

You're up and running, but don't stop now - this is just the beginning of your journey. Now it's time to Customizations.

Integrations for Devs

Rafael Fernandes — Thu, 22 Aug 2024 14:46:54 GMT

Revision 25 posted to Dev Tutorials by Rafael Fernandes on 8/22/2024 2:46:54 PM

Integration Approaches

The Sugar platform is extremely powerful, flexible, and allows for easy integration. This flexibility means that determining the best approach for your use case scenario is the key to success.

Push/Pull from Sugar via REST API
- Recommended approach
- Developers have full control over integration
- Integration can be stopped and systems will continue to work
- Retry mechanism: Resume integrations at any time (identify deltas through "last_update_time" flags)
- The time delay from/to Sugar is minimal
- Sugar REST API offers almost everything you need, and can be further extended via customization
Push to Sugar, Sugar pushes to an external queue in realtime
- Use Sugar Events to trigger through Logic Hooks
- Requires Logic Hooks (code customization) to be created and deployed
- Does not offer a "retry mechanism", if a logic hook fails to deliver to a queue or contact an external system
- Synchronous in nature, requires a response from an external system
- Needs to handle dependencies manually (contact can only be created after account)
- Good to have a middleware/queue in front of Sugar to receive those event triggers to reliably manage peak loads
Realtime: Embed your app into Sugar through Dashlets
- Simplest approach
- Often requires web user-based authentication
- All load/traffic goes directly to your system, which makes your system the performance bottleneck

REST API Webservices

Sugar REST API Overview
- Fully RESTfull (GET, POST, PUT, DELETE)
- OAuth2 token based
- All fields and modules are available through the API automatically
- Metadata API provides everything you need to know about your Sugar instance.

Topics

Common APIs

Metadata
- Endpoint with current system's structure
- Modules, fields, relationships, layouts
- Use carefully, its payload can be MBs in size, cache as much as possible
- GET /metadata (use filters as much as possible)
- It does not retrieve labels for dropdowns, use language API to do so
- 3 Tips for using the Sugar Metadata API
Language
- Endpoint to retrieve labels
- Dropdown list values
- Any language-specific content
- GET /lang/<language_code>
CRUD (Create, Read, Update, Delete) records
- Read: GET /<module>/:record
- Create: POST /<module>
- Update: PUT /<module>/:record
- Delete: DELETE /<module>/:record
- Filter: POST /<module>/filter
  - You can use GET as well
  - POST solves the issue when a query is too long and hits HTTP limits
- Retrieve records related to another module: GET /<module>/:record/link/:link_name
- Creates a relationship to a pre-existing record: POST /<module>/:record/link/:link_name/:remote_id

Performance and Best Practices

You should consider the following guidelines when implementing your integrations:

Use Sugar's sync_key to link to remote IDs
- Sugar provides in every module a sync_key field
- sync_key is a unique identifier for that module that links back to your external system's generated key
- For example, account ID from ERP is AC0001, set sync_key (pass as a parameter in the POST) and sugar will create a record in account with sync_key=AC0001
- Next patch/update, sugar will check "where sync_key='AC0001'" and update it (it is indexed)
Use Sugar Integrate Upsert APIs
- Sugar's "update or insert" API based on sync_key
- Simplifies a common operation - if record exists, update it, otherwise create it (GET followed by a PUT or POST)
- Upsert by sync_key
- Get by sync_key
- Delete by sync_key
- Set a sync on existing record (without sync_key)
- Create relationship based on sync_key
- Delete relationship based on sync_key
Use Sugar Bulk API
- An endpoint that encapsulates multiple API calls into one single HTTP request
- Requests are executed synchronously (one after the other)
- Reducing network latency between calls
- Combined with Upsert provides the best performance
- Careful not to add too many requests to it
- Start small (5 to 10 requests) and increase until you reach its max capacity
Polling and filtering time-based with Filter API
- Integration gateway (or your external system) asks Sugar every X minutes
- Request Filter API using max_num (max number of records), offset and fields
- The response will provide the data as well as next_offset (offset can be seen as pagination)
- if next_offset is -1, no more records to go through
Initial Data Load into Sugar
- Use Bulk + Upsert to achieve data loads
- Millions of records may take a little while to process, plan ahead (over the weekend)
- Use multi-thread processes to load (for example 20 threads sending 20 bulk upsert requests)
- Careful with Sugar Cloud rate limits
- It's always a good idea to let Sugar Support know you're data loading, they will be considerate.
Understanding PHP limitations
- PHP is single-threaded with limited resources to process your request
- If you send too much data using bulk, you may run out of memory for that request
- Push to the limits but give some room for PHP to finish the request gracefully
Pagination for millions of records by using OFFSET will degrade performance
- We rely on DB to find, sort and limit records
- Nice article explaining how this works in details
- Instead of offsets, store the last processed ID and use it in the WHERE clause and sort by ID
- Example
  - Instead of: (/v11_25/Leads?max_num=1000&offset=4619000&order_by=id)
  - Do this (/v11_25/Leads?filter=[{"id":”<last_id>"}]&max_num=1000&order_by=id)
- If you need to add a date, make sure to add it as part of the filter and order

You're up and running, but don't stop now - this is just the beginning of your journey. Now it's time to Customizations.

Integrations for Devs

Rafael Fernandes — Mon, 24 Jun 2024 12:33:52 GMT

Revision 24 posted to Dev Tutorials by Rafael Fernandes on 6/24/2024 12:33:52 PM

Integration Approaches

The Sugar platform is extremely powerful, flexible, and allows for easy integration. This flexibility means that determining the best approach for your use case scenario is the key to success.

Push/Pull from Sugar via REST API
- Recommended approach
- Developers have full control over integration
- Integration can be stopped and systems will continue to work
- Retry mechanism: Resume integrations at any time (identify deltas through "last_update_time" flags)
- The time delay from/to Sugar is minimal
- Sugar REST API offers almost everything you need, and can be further extended via customization
Push to Sugar, Sugar pushes to an external queue in realtime
- Use Sugar Events to trigger through Logic Hooks
- Requires Logic Hooks (code customization) to be created and deployed
- Does not offer a "retry mechanism", if a logic hook fails to deliver to a queue or contact an external system
- Synchronous in nature, requires a response from an external system
- Needs to handle dependencies manually (contact can only be created after account)
- Good to have a middleware/queue in front of Sugar to receive those event triggers to reliably manage peak loads
Realtime: Embed your app into Sugar through Dashlets
- Simplest approach
- Often requires web user-based authentication
- All load/traffic goes directly to your system, which makes your system the performance bottleneck

REST API Webservices

Sugar REST API Overview
- Fully RESTfull (GET, POST, PUT, DELETE)
- OAuth2 token based
- All fields and modules are available through the API automatically
- Metadata API provides everything you need to know about your Sugar instance.

Topics

Common APIs

Metadata
- Endpoint with current system's structure
- Modules, fields, relationships, layouts
- Use carefully, its payload can be MBs in size, cache as much as possible
- GET /metadata (use filters as much as possible)
- It does not retrieve labels for dropdowns, use language API to do so
- 3 Tips for using the Sugar Metadata API
Language
- Endpoint to retrieve labels
- Dropdown list values
- Any language-specific content
- GET /lang/<language_code>
CRUD (Create, Read, Update, Delete) records
- Read: GET /<module>/:record
- Create: POST /<module>
- Update: PUT /<module>/:record
- Delete: DELETE /<module>/:record
- Filter: POST /<module>/filter
  - You can use GET as well
  - POST solves the issue when a query is too long and hits HTTP limits
- Retrieve records related to another module: GET /<module>/:record/link/:link_name
- Creates a relationship to a pre-existing record: POST /<module>/:record/link/:link_name/:remote_id

Performance and Best Practices

You should consider the following guidelines when implementing your integrations:

Use Sugar's sync_key to link to remote IDs
- Sugar provides in every module a sync_key field
- sync_key is a unique identifier for that module that links back to your external system's generated key
- For example, account ID from ERP is AC0001, set sync_key (pass as a parameter in the POST) and sugar will create a record in account with sync_key=AC0001
- Next patch/update, sugar will check "where sync_key='AC0001'" and update it (it is indexed)
Use Sugar Integrate Upsert APIs
- Sugar's "update or insert" API based on sync_key
- Simplifies a common operation - if record exists, update it, otherwise create it (GET followed by a PUT or POST)
- Upsert by sync_key
- Get by sync_key
- Delete by sync_key
- Set a sync on existing record (without sync_key)
- Create relationship based on sync_key
- Delete relationship based on sync_key
Use Sugar Bulk API
- An endpoint that encapsulates multiple API calls into one single HTTP request
- Requests are executed synchronously (one after the other)
- Reducing network latency between calls
- Combined with Upsert provides the best performance
- Careful not to add too many requests to it
- Start small (5 to 10 requests) and increase until you reach its max capacity
Polling and filtering time-based with Filter API
- Integration gateway (or your external system) asks Sugar every X minutes
- Request Filter API using max_num (max number of records), offset and fields
- The response will provide the data as well as next_offset (offset can be seen as pagination)
- if next_offset is -1, no more records to go through
Initial Data Load into Sugar
- Use Bulk + Upsert to achieve data loads
- Millions of records may take a little while to process, plan ahead (over the weekend)
- Use multi-thread processes to load (for example 20 threads sending 20 bulk upsert requests)
- Careful with Sugar Cloud rate limits
- It's always a good idea to let Sugar Support know you're data loading, they will be considerate.
Understanding PHP limitations
- PHP is single-threaded with limited resources to process your request
- If you send too much data using bulk, you may run out of memory for that request
- Push to the limits but give some room for PHP to finish the request gracefully
Pagination for millions of records by using OFFSET will degrade performance
- We rely on DB to find, sort and limit records
- Nice article explaining how this works in details
- Instead of offsets, store the last processed ID and use it in the WHERE clause and sort by ID
- Example
  - Instead of: (/v11_25/Leads?max_num=1000&offset=4619000&order_by=id)
  - Do this (/v11_25/Leads?filter=[{"id":”<last_id>"}]&max_num=1000&order_by=id)
- If you need to add a date, make sure to add it as part of the filter and order

You're up and running, but don't stop now - this is just the beginning of your journey. Now it's time to Customizations.

Integrations for Devs

Alex Nassi — Fri, 05 Aug 2022 17:45:09 GMT

Revision 23 posted to Dev Tutorials by Alex Nassi on 8/5/2022 5:45:09 PM

Integration Approaches

The Sugar platform is extremely powerful, flexible, and allows for easy integration. This flexibility means that determining the best approach for your use case scenario is the key to success.

Push/Pull from Sugar via REST API
- Recommended approach
- Developers have full control over integration
- Integration can be stopped and systems will continue to work
- Retry mechanism: Resume integrations at any time (identify deltas through "last_update_time" flags)
- The time delay from/to Sugar is minimal
- Sugar REST API offers almost everything you need, and can be further extended via customization
Push to Sugar, Sugar pushes to an external queue in realtime
- Use Sugar Events to trigger through Logic Hooks
- Requires Logic Hooks (code customization) to be created and deployed
- Does not offer a "retry mechanism", if a logic hook fails to deliver to a queue or contact an external system
- Synchronous in nature, requires a response from an external system
- Needs to handle dependencies manually (contact can only be created after account)
- Good to have a middleware/queue in front of Sugar to receive those event triggers to reliably manage peak loads
Realtime: Embed your app into Sugar through Dashlets
- Simplest approach
- Often requires web user-based authentication
- All load/traffic goes directly to your system, which makes your system the performance bottleneck

REST API Webservices

Sugar REST API Overview
- Fully RESTfull (GET, POST, PUT, DELETE)
- OAuth2 token based
- All fields and modules are available through the API automatically
- Metadata API provides everything you need to know about your Sugar instance.

Topics

Common APIs

Metadata
- Endpoint with current system's structure
- Modules, fields, relationships, layouts
- Use carefully, its payload can be MBs in size, cache as much as possible
- GET /metadata (use filters as much as possible)
- It does not retrieve labels for dropdowns, use language API to do so
- 3 Tips for using the Sugar Metadata API
Language
- Endpoint to retrieve labels
- Dropdown list values
- Any language-specific content
- GET /lang/<language_code>
CRUD (Create, Read, Update, Delete) records
- Read: GET /<module>/:record
- Create: POST /<module>
- Update: PUT /<module>/:record
- Delete: DELETE /<module>/:record
- Filter: POST /<module>/filter
  - You can use GET as well
  - POST solves the issue when a query is too long and hits HTTP limits
- Retrieve records related to another module: GET /<module>/:record/link/:link_name
- Creates a relationship to a pre-existing record: POST /<module>/:record/link/:link_name/:remote_id

Performance and Best Practices

You should consider the following guidelines when implementing your integrations:

Use Sugar's sync_key to link to remote IDs
- Sugar provides in every module a sync_key field
- sync_key is a unique identifier for that module that links back to your external system's generated key
- For example, account ID from ERP is AC0001, set sync_key (pass as a parameter in the POST) and sugar will create a record in account with sync_key=AC0001
- Next patch/update, sugar will check "where sync_key='AC0001'" and update it (it is indexed)
Use Sugar Integrate Upsert APIs
- Sugar's "update or insert" API based on sync_key
- Simplifies a common operation - if record exists, update it, otherwise create it (GET followed by a PUT or POST)
- Upsert by sync_key
- Get by sync_key
- Delete by sync_key
- Set a sync on existing record (without sync_key)
- Create relationship based on sync_key
- Delete relationship based on sync_key
Use Sugar Bulk API
- An endpoint that encapsulates multiple API calls into one single HTTP request
- Requests are executed synchronously (one after the other)
- Reducing network latency between calls
- Combined with Upsert provides the best performance
- Careful not to add too many requests to it
- Start small (5 to 10 requests) and increase until you reach its max capacity
Polling and filtering time-based with Filter API
- Integration gateway (or your external system) asks Sugar every X minutes
- Request Filter API using max_num (max number of records), offset and fields
- The response will provide the data as well as next_offset (offset can be seen as pagination)
- if next_offset is -1, no more records to go through
Initial Data Load into Sugar
- Use Bulk + Upsert to achieve data loads
- Millions of records may take a little while to process, plan ahead (over the weekend)
- Use multi-thread processes to load (for example 20 threads sending 20 bulk upsert requests)
- Careful with Sugar Cloud rate limits
- It's always a good idea to let Sugar Support know you're data loading, they will be considerate.
Understanding PHP limitations
- PHP is single-threaded with limited resources to process your request
- If you send too much data using bulk, you may run out of memory for that request
- Push to the limits but give some room for PHP to finish the request gracefully

You're up and running, but don't stop now - this is just the beginning of your journey. Now it's time to Customizations.

Integrations for Devs

Matt Marum — Thu, 21 Jul 2022 18:49:00 GMT

Revision 21 posted to Dev Tutorials by Matt Marum on 7/21/2022 6:49:00 PM

Integration Approaches

The Sugar platform is extremely powerful, flexible, and allows for easy integration. This flexibility means that determining the best approach for your use case scenario is the key to success.

Push/Pull from Sugar via REST API
- Recommended approach
- Developers have full control over integration
- Integration can be stopped and systems will continue to work
- Retry mechanism: Resume integrations at any time (identify deltas through "last_update_time" flags)
- The time delay from/to Sugar is minimal
- Sugar REST API offers almost everything you need, and can be further extended via customization
Push to Sugar, Sugar pushes to an external queue in realtime
- Use Sugar Events to trigger through Logic Hooks
- Requires Logic Hooks (code customization) to be created and deployed
- Does not offer a "retry mechanism", if a logic hook fails to deliver to a queue or contact an external system
- Synchronous in nature, requires a response from an external system
- Needs to handle dependencies manually (contact can only be created after account)
- Good to have a middleware/queue in front of Sugar to receive those event triggers to reliably manage peak loads
Realtime: Embed your app into Sugar through Dashlets
- Simplest approach
- Often requires web user-based authentication
- All load/traffic goes directly to your system, which makes your system the performance bottleneck

REST API Webservices

Sugar REST API Overview
- Fully RESTfull (GET, POST, PUT, DELETE)
- OAuth2 token based
- All fields and modules are available through the API automatically
- Metadata API provides everything you need to know about your Sugar instance.

Topics

Common APIs

Metadata
- Endpoint with current system's structure
- Modules, fields, relationships, layouts
- Use carefully, its payload can be MBs in size, cache as much as possible
- GET /metadata (use filters as much as possible)
- It does not retrieve labels for dropdowns, use language API to do so
- 3 Tips for using the Sugar Metadata API
Language
- Endpoint to retrieve labels
- Dropdown list values
- Any language-specific content
- GET /lang/<language_code>
CRUD (Create, Read, Update, Delete) records
- Read: GET /<module>/:record
- Create: POST /<module>
- Update: PUT /<module>/:record
- Delete: DELETE /<module>/:record
- Filter: POST /<module>/filter
  - You can use GET as well
  - POST solves the issue when a query is too long and hits HTTP limits
- Retrieve records related to another module: GET /<module>/:record/link/:link_name
- Creates a relationship to a pre-existing record: POST /<module>/:record/link/:link_name/:remote_id

Performance and Best Practices

You should consider the following guidelines when implementing your integrations:

Use Sugar's sync_key to link to remote IDs
- Sugar provides in every module a sync_key field
- sync_key is a unique identifier for that module that links back to your external system's generated key
- For example, account ID from ERP is AC0001, set sync_key (pass as a parameter in the POST) and sugar will create a record in account with sync_key=AC0001
- Next patch/update, sugar will check "where sync_key='AC0001'" and update it (it is indexed)
Use Sugar Integrate Upsert APIs
- Sugar's "update or insert" API based on sync_key
- Simplifies a common operation - if record exists, update it, otherwise create it (GET followed by a PUT or POST)
- Upsert by sync_key
- Get by sync_key
- Delete by sync_key
- Set a sync on existing record (without sync_key)
- Create relationship based on sync_key
- Delete relationship based on sync_key
Use Sugar Bulk API
- An endpoint that encapsulates multiple API calls into one single HTTP request
- Requests are executed synchronously (one after the other)
- Reducing network latency between calls
- Combined with Upsert provides the best performance
- Careful not to add too many requests to it
- Start small (5 to 10 requests) and increase until you reach its max capacity
Polling and filtering time-based with Filter API
- Integration gateway (or your external system) asks Sugar every X minutes
- Request Filter API using max_num (max number of records), offset and fields
- The response will provide the data as well as next_offset (offset can be seen as pagination)
- if next_offset is -1, no more records to go through
Initial Data Load into Sugar
- Use Bulk + Upsert to achieve data loads
- Millions of records may take a little while to process, plan ahead (over the weekend)
- Use multi-thread processes to load (for example 20 threads sending 20 bulk upsert requests)
- Careful with Sugar Cloud rate limits
- It's always a good idea to let Sugar Support know you're data loading, they will be considerate.
Understanding PHP limitations
- PHP is single-threaded with limited resources to process your request
- If you send too much data using bulk, you may run out of memory for that request
- Push to the limits but give some room for PHP to finish the request gracefully

You're up and running, but don't stop now - this is just the beginning of your journey. Now it's time to Customizations.

Integrations for Devs

Matt Marum — Thu, 21 Jul 2022 18:49:00 GMT

Revision 22 posted to Dev Tutorials by Matt Marum on 7/21/2022 6:49:00 PM

Integration Approaches

The Sugar platform is extremely powerful, flexible, and allows for easy integration. This flexibility means that determining the best approach for your use case scenario is the key to success.

Push/Pull from Sugar via REST API
- Recommended approach
- Developers have full control over integration
- Integration can be stopped and systems will continue to work
- Retry mechanism: Resume integrations at any time (identify deltas through "last_update_time" flags)
- The time delay from/to Sugar is minimal
- Sugar REST API offers almost everything you need, and can be further extended via customization
Push to Sugar, Sugar pushes to an external queue in realtime
- Use Sugar Events to trigger through Logic Hooks
- Requires Logic Hooks (code customization) to be created and deployed
- Does not offer a "retry mechanism", if a logic hook fails to deliver to a queue or contact an external system
- Synchronous in nature, requires a response from an external system
- Needs to handle dependencies manually (contact can only be created after account)
- Good to have a middleware/queue in front of Sugar to receive those event triggers to reliably manage peak loads
Realtime: Embed your app into Sugar through Dashlets
- Simplest approach
- Often requires web user-based authentication
- All load/traffic goes directly to your system, which makes your system the performance bottleneck

REST API Webservices

Sugar REST API Overview
- Fully RESTfull (GET, POST, PUT, DELETE)
- OAuth2 token based
- All fields and modules are available through the API automatically
- Metadata API provides everything you need to know about your Sugar instance.

Topics

Common APIs

Metadata
- Endpoint with current system's structure
- Modules, fields, relationships, layouts
- Use carefully, its payload can be MBs in size, cache as much as possible
- GET /metadata (use filters as much as possible)
- It does not retrieve labels for dropdowns, use language API to do so
- 3 Tips for using the Sugar Metadata API
Language
- Endpoint to retrieve labels
- Dropdown list values
- Any language-specific content
- GET /lang/<language_code>
CRUD (Create, Read, Update, Delete) records
- Read: GET /<module>/:record
- Create: POST /<module>
- Update: PUT /<module>/:record
- Delete: DELETE /<module>/:record
- Filter: POST /<module>/filter
  - You can use GET as well
  - POST solves the issue when a query is too long and hits HTTP limits
- Retrieve records related to another module: GET /<module>/:record/link/:link_name
- Creates a relationship to a pre-existing record: POST /<module>/:record/link/:link_name/:remote_id

Performance and Best Practices

You should consider the following guidelines when implementing your integrations:

Use Sugar's sync_key to link to remote IDs
- Sugar provides in every module a sync_key field
- sync_key is a unique identifier for that module that links back to your external system's generated key
- For example, account ID from ERP is AC0001, set sync_key (pass as a parameter in the POST) and sugar will create a record in account with sync_key=AC0001
- Next patch/update, sugar will check "where sync_key='AC0001'" and update it (it is indexed)
Use Sugar Integrate Upsert APIs
- Sugar's "update or insert" API based on sync_key
- Simplifies a common operation - if record exists, update it, otherwise create it (GET followed by a PUT or POST)
- Upsert by sync_key
- Get by sync_key
- Delete by sync_key
- Set a sync on existing record (without sync_key)
- Create relationship based on sync_key
- Delete relationship based on sync_key
Use Sugar Bulk API
- An endpoint that encapsulates multiple API calls into one single HTTP request
- Requests are executed synchronously (one after the other)
- Reducing network latency between calls
- Combined with Upsert provides the best performance
- Careful not to add too many requests to it
- Start small (5 to 10 requests) and increase until you reach its max capacity
Polling and filtering time-based with Filter API
- Integration gateway (or your external system) asks Sugar every X minutes
- Request Filter API using max_num (max number of records), offset and fields
- The response will provide the data as well as next_offset (offset can be seen as pagination)
- if next_offset is -1, no more records to go through
Initial Data Load into Sugar
- Use Bulk + Upsert to achieve data loads
- Millions of records may take a little while to process, plan ahead (over the weekend)
- Use multi-thread processes to load (for example 20 threads sending 20 bulk upsert requests)
- Careful with Sugar Cloud rate limits
- It's always a good idea to let Sugar Support know you're data loading, they will be considerate.
Understanding PHP limitations
- PHP is single-threaded with limited resources to process your request
- If you send too much data using bulk, you may run out of memory for that request
- Push to the limits but give some room for PHP to finish the request gracefully

You're up and running, but don't stop now - this is just the beginning of your journey. Now it's time to Customizations.

Integrations for Devs

Rafael Fernandes — Thu, 14 Jul 2022 20:28:02 GMT

Revision 20 posted to Dev Tutorials by Rafael Fernandes on 7/14/2022 8:28:02 PM

Integration Approaches

Sugar platform is extremely powerful and easy to integrate with. Determining the right approach for your use case scenario is the key to success.

Push/Pull from Sugar via REST API
- Recommended approach
- Developers have full control over integration
- Integration can be stopped and systems will continue to work
- Retry mechanism: Resume integrations at any time (bringing only delta changes through "last_udpdate_time" flags)
- Time delay from/to Sugar is minimum and bearable
- Sugar REST API offers everything you need, but can be extended
Push to Sugar, Sugar pushes to external queue in realtime
- Uses Sugar Events to trigger through Logic Hooks
- Requires Logic Hooks to be created and deployed
- Does not offer "retry mechanism", if a logic hook fails to deliver to a queue or contact external system
- Synchronous in nature, requires a response from external system
- Needs to handle dependencies manually (contact can only be created after account)
- Good to have a middleware/queue in front of Sugar to receive those event triggers (not mandatory but would make it "asynchronous"
Realtime: Embed your app into Sugar through Dashlets
- Simplest approach
- Often requires user-based authentication
- All load/traffic goes directly to your system, careful with bottlenecks

REST API Webservices

Sugar REST API Overview
- Fully RESTfull (GET, POST, PUT, DELETE)
- OAuth2 token based
- All fields and modules are available through the API automatically
- Metadata API provides everything you need to know about your Sugar instance.

Topics

Common APIs

Metadata
- Endpoint with current system's structure
- Modules, fields, relationships, layouts
- Use carefully, its payload can be MBs in size, cache as much as possible
- GET /metadata (use filters as much as possible)
- It does not retrieve lables for dropdowns, use language api to do so
- 3 Tips for using the Sugar Metadata API
Language
- Endpoint to retrieve labels
- Dropdown list values
- Any language specific content
- GET /lang/<language_code>
CRUD (Create, Read, Update, Delete) records
- Read: GET /<module>/:record
- Create: POST /<module>
- Update: PUT /<module>/:record
- Delete: DELETE /<module>/:record
- Filter: POST /<module>/filter
  - You can use GET as well
  - POST solves the issue when a query is too long and hits HTTP limits
- Retrieve records related to another module: GET /<module>/:record/link/:link_name
- Creates a relationship to a pre-existing record: POST /<module>/:record/link/:link_name/:remote_id

Performance and Best Practices

You should consider the following guidelines when implementing your integrations:

Use Sugar's sync_key
- Sugar provides in every module a sync_key field
- sync_key is a unique identifier for that module that links back to your external system's generated key
- For example, account ID from ERP is AC0001, set sync_key (pass as parameter in the POST) and sugar will create a record in account with sync_key=AC0001
- Next patch/update, sugar will check "where sync_key='AC0001'" and update it (it is indexed)
Use Sugar Integrate Upsert APIs
- Sugar's "update or insert" API based on sync_key
- Replaces commonly used check if exists, update or create (GET and POST or PUT)
- Upsert by sync_key
- Get by sync_key
- Delete by sync_key
- Set a sync on existing record (without sync_key)
- Create relationship based on sync_key
- Delete relationship based on sync_key
Use Sugar Bulk API
- Endpoint that encapsulates multiple API calls into one single HTTP request
- Requests are executed synchronously (one after the other)
- Reducing network latency between calls
- Combined with Upsert provides the best performance
- Careful not to add too many requests to it
- Start small (5 to 10 requests) and increase until you reach it's max capacity
Polling and filtering time-based with Filter API
- Integration gateway (or your external system) asks Sugar every X minutes
- Request Filter API using max_num (max number of records), offset and fields
- Response will provide the data as well as next_offset (offset can be seen as pagination)
- if next_offset is -1, no more records to go through
Initial Data Load into Sugar
- Use Bulk + Upsert to achieve data loads
- Millions of records may take a little while to process, plan ahead (over the weekend)
- Use multi-thread processes to load (for example 20 threads sending 20 bulk upsert requests)
- Careful with Sugar Cloud rate limits
- It's always a good idea to let Sugar Support know you're data loading, they will be considerate.
Understanding PHP limitations
- PHP is single threaded with limited resources to process your request
- If you send too much data using bulk, you may run out of memory for that request
- Push to the limits but give some room for PHP to finish the request gracefully

You're up and running, but don't stop now - this is just the beginning of your journey. Now it's time to Customizations.

Integrations for Devs

Rafael Fernandes — Thu, 14 Jul 2022 15:51:01 GMT

Revision 19 posted to Dev Tutorials by Rafael Fernandes on 7/14/2022 3:51:01 PM

Integration Approaches

Sugar platform is extremely powerful and easy to integrate with. Determining the right approach for your use case scenario is the key to success.

Push/Pull from Sugar via REST API
- Recommended approach
- Developers have full control over integration
- Integration can be stopped and systems will continue to work
- Retry mechanism: Resume integrations at any time (bringing only delta changes through "last_udpdate_time" flags)
- Time delay from/to Sugar is minimum and bearable
- Sugar REST API offers everything you need, but can be extended
Push to Sugar, Sugar pushes to external queue in realtime
- Uses Sugar Events to trigger through Logic Hooks
- Requires Logic Hooks to be created and deployed
- Does not offer "retry mechanism", if a logic hook fails to deliver to a queue or contact external system
- Synchronous in nature, requires a response from external system
- Needs to handle dependencies manually (contact can only be created after account)
- Good to have a middleware/queue in front of Sugar to receive those event triggers (not mandatory but would make it "asynchronous"
Realtime: Embed your app into Sugar through Dashlets
- Simplest approach
- Often requires user-based authentication
- All load/traffic goes directly to your system, careful with bottlenecks

REST API Webservices

Sugar REST API Overview
- Fully RESTfull (GET, POST, PUT, DELETE)
- OAuth2 token based
- All fields and modules are available through the API automatically
- Metadata API provides everything you need to know about your Sugar instance.

Topics

Common APIs

Metadata
- Endpoint with current system's structure
- Modules, fields, relationships, layouts
- Use carefully, its payload can be MBs in size, cache as much as possible
- GET /metadata (use filters as much as possible)
- It does not retrieve lables for dropdowns, use language api to do so
- 3 Tips for using the Sugar Metadata API
Language
- Endpoint to retrieve labels
- Dropdown list values
- Any language specific content
- GET /lang/<language_code>
CRUD (Create, Read, Update, Delete) records
- Read: GET /<module>/:record
- Create: POST /<module>
- Update: PUT /<module>/:record
- Delete: DELETE /<module>/:record
- Filter: POST /<module>/filter
  - You can use GET as well
  - POST solves the issue when a query is too long and hits HTTP limits
- Retrieve records related to another module: GET /<module>/:record/link/:link_name
- Creates a relationship to a pre-existing record: POST /<module>/:record/link/:link_name/:remote_id

Performance and Best Practices

You should consider the following guidelines when implementing your integrations:

Use Sugar's sync_key
- Sugar provides in every module a sync_key field
- sync_key is a unique identifier for that module that links back to your external system's generated key
- For example, account ID from ERP is AC0001, set sync_key (pass as parameter in the POST) and sugar will create a record in account with sync_key=AC0001
- Next patch/update, sugar will check "where sync_key='AC0001'" and update it (it is indexed)
Use Sugar Integrate Upsert APIs
- Sugar's "update or insert" API based on sync_key
- Replaces commonly used check if exists, update or create (GET and POST or PUT)
- Upsert by sync_key
- Get by sync_key
- Delete by sync_key
- Set a sync on existing record (without sync_key)
- Create relationship based on sync_key
- Delete relationship based on sync_key
Use Sugar Bulk API
- Endpoint that encapsulates multiple API calls into one single HTTP request
- Requests are executed synchronously (one after the other)
- Reducing network latency between calls
- Combined with Upsert provides the best performance
- Careful not to add too many requests to it
- Start small (5 to 10 requests) and increase until you reach it's max capacity
Polling and filtering time-based with Filter API
- Integration gateway (or your external system) asks Sugar every X minutes
- Request Filter API using max_num (max number of records), offset and fields
- Response will provide the data as well as next_offset (offset can be seen as pagination)
- if next_offset is -1, no more records to go through
Initial Data Load into Sugar
- Use Bulk + Upsert to achieve data loads
- Millions of records may take a little while to process, plan ahead (over the weekend)
- Use multi-thread processes to load (for example 20 threads sending 20 bulk upsert requests)
- Careful with Sugar Cloud rate limits
- It's always a good idea to let Sugar Support know you're data loading, they will be considerate.
Understanding PHP limitations
- PHP allocates OS resources to process your request
- If you send too much data using bulk, you may run out of memory for that request
- Push to the limits but give some room for PHP to finish the request gracefully

You're up and running, but don't stop now - this is just the beginning of your journey. Now it's time to Customizations.

Integrations for Devs

Rafael Fernandes — Thu, 14 Jul 2022 15:44:15 GMT

Revision 18 posted to Dev Tutorials by Rafael Fernandes on 7/14/2022 3:44:15 PM

Integration Approaches

Sugar platform is extremely powerful and easy to integrate with. Determining the right approach for your use case scenario is the key to success.

Push/Pull from Sugar via REST API
- Recommended approach
- Developers have full control over integration
- Integration can be stopped and systems will continue to work
- Retry mechanism: Resume integrations at any time (bringing only delta changes through "last_udpdate_time" flags)
- Time delay from/to Sugar is minimum and bearable
- Sugar REST API offers everything you need, but can be extended
Push to Sugar, Sugar pushes to external queue in realtime
- Uses Sugar Events to trigger through Logic Hooks
- Requires Logic Hooks to be created and deployed
- Does not offer "retry mechanism", if a logic hook fails to deliver to a queue or contact external system
- Synchronous in nature, requires a response from external system
- Needs to handle dependencies manually (contact can only be created after account)
- Good to have a middleware/queue in front of Sugar to receive those event triggers (not mandatory but would make it "asynchronous"
Realtime: Embed your app into Sugar through Dashlets
- Simplest approach
- Often requires user-based authentication
- All load/traffic goes directly to your system, careful with bottlenecks

REST API Webservices

Sugar REST API Overview
- Fully RESTfull (GET, POST, PUT, DELETE)
- OAuth2 token based
- All fields and modules are available through the API automatically
- Metadata API provides everything you need to know about your Sugar instance.

Topics

Common APIs

Metadata
- Endpoint with current system's structure
- Modules, fields, relationships, layouts
- Use carefully, its payload can be MBs in size, cache as much as possible
- GET /metadata (use filters as much as possible)
- It does not retrieve lables for dropdowns, use language api to do so
- 3 Tips for using the Sugar Metadata API
Language
- Endpoint to retrieve labels
- Dropdown list values
- Any language specific content
- GET /lang/<language_code>
CRUD (Create, Read, Update, Delete) records
- Read: GET /<module>/:record
- Create: POST /<module>
- Update: PUT /<module>/:record
- Delete: DELETE /<module>/:record
- Filter: POST /<module>/filter
  - You can use GET as well
  - POST solves the issue when a query is too long and hits HTTP limits
- Retrieve records related to another module: GET /<module>/:record/link/:link_name
- Creates a relationship to a pre-existing record: POST /<module>/:record/link/:link_name/:remote_id

Performance and Best Practices

You should consider the following guidelines when implementing your integrations:

Use Sugar's sync_key
- Sugar provides in every module a sync_key field
- sync_key is a unique identifier for that module that links back to your external system's generated key
- For example, account ID from ERP is AC0001, set sync_key (pass as parameter in the POST) and sugar will create a record in account with sync_key=AC0001
- Next patch/update, sugar will check "where sync_key='AC0001'" and update it (it is indexed)
Use Sugar Integrate Upsert APIs
- Sugar's "update or insert" API based on sync_key
- Replaces commonly used check if exists, update or create (GET and POST or PUT)
- Upsert by sync_key
- Get by sync_key
- Delete by sync_key
- Set a sync on existing record (without sync_key)
- Create relationship based on sync_key
- Delete relationship based on sync_key
Use Sugar Bulk API
- Endpoint that encapsulates multiple API calls into one single HTTP request
- Requests are executed synchronously (one after the other)
- Reducing network latency between calls
- Combined with Upsert provides the best performance
- Careful not to add too many requests to it
- Start small (5 to 10 requests) and increase until you reach it's max capacity
Polling and filtering time-based with Filter API
- Integration gateway (or your external system) asks Sugar every X minutes
- Request Filter API using max_num (max number of records), offset and fields
- Response will provide the data as well as next_offset (offset can be seen as pagination)
- if next_offset is -1, no more records to go through
Initial Data Load into Sugar
- Use Bulk + Upsert to achieve data loads
- Millions of records may take a little while to process, plan ahead (over the weekend)
- Use multi-thread processes to load (for example 20 threads sending 20 bulk upsert requests)
- Careful with Sugar Cloud rate limits
- It's always a good idea to let Sugar Support know you're data loading, they will be considerate.
Understanding PHP limitations
- PHP allocates OS resources to process your request
- If you send too much data using bulk, you may run out of memory for that request
- Push to the limits but give some room for PHP to finish the request gracefully

You're up and running, but don't stop now - this is just the beginning of your journey. Now it's time to Customizations.

Integrations for Devs

Rafael Fernandes — Thu, 14 Jul 2022 15:43:11 GMT

Revision 17 posted to Dev Tutorials by Rafael Fernandes on 7/14/2022 3:43:11 PM

Integration Approaches

Sugar platform is extremely powerful and easy to integrate with. Determining the right approach for your use case scenario is the key to success.

Push/Pull from Sugar via REST API
- Recommended approach
- Developers have full control over integration
- Integration can be stopped and systems will continue to work
- Retry mechanism: Resume integrations at any time (bringing only delta changes through "last_udpdate_time" flags)
- Time delay from/to Sugar is minimum and bearable
- Sugar REST API offers everything you need, but can be extended
Push to Sugar, Sugar pushes to external queue in realtime
- Uses Sugar Events to trigger through Logic Hooks
- Requires Logic Hooks to be created and deployed
- Does not offer "retry mechanism", if a logic hook fails to deliver to a queue or contact external system
- Synchronous in nature, requires a response from external system
- Needs to handle dependencies manually (contact can only be created after account)
- Good to have a middleware/queue in front of Sugar to receive those event triggers (not mandatory but would make it "asynchronous"
Realtime: Embed your app into Sugar through Dashlets
- Simplest approach
- Often requires user-based authentication
- All load/traffic goes directly to your system, careful with bottlenecks

REST API Webservices

Sugar REST API Overview
- Fully RESTfull (GET, POST, PUT, DELETE)
- OAuth2 token based
- All fields and modules are available through the API automatically
- Metadata API provides everything you need to know about your Sugar instance.

Topics

Common APIs

Metadata
- Endpoint with current system's structure
- Modules, fields, relationships, layouts
- Use carefully, its payload can be MBs in size, cache as much as possible
- GET /metadata (use filters as much as possible)
- It does not retrieve lables for dropdowns, use language api to do so
- 3 Tips for using the Sugar Metadata API
Language
- Endpoint to retrieve labels
- Dropdown list values
- Any language specific content
- GET /lang/<language_code>
CRUD (Create, Read, Update, Delete) records
- Read: GET /<module>/:record
- Create: POST /<module>
- Update: PUT /<module>/:record
- Delete: DELETE /<module>/:record
- Filter: POST /<module>/filter
  - You can use GET as well
  - POST solves the issue when a query is too long and hits HTTP limits
- Retrieve records related to another module: GET /<module>/:record/link/:link_name
- Creates a relationship to a pre-existing record: POST /<module>/:record/link/:link_name/:remote_id

Performance and Best Practices

You should consider the following guidelines when implementing your integrations:

Use Sugar's sync_key
- Sugar provides in every module a sync_key field
- sync_key is a unique identifier for that module that links back to your external system's generated key
- For example, account ID from ERP is AC0001, set sync_key (pass as parameter in the POST) and sugar will create a record in account with sync_key=AC0001
- Next patch/update, sugar will check "where sync_key='AC0001'" and update it (it is indexed)
Use Sugar Integrate Upsert APIs
- Sugar's "update or insert" API based on sync_key
- Replaces commonly used check if exists, update or create (GET and POST or PUT)
- Upsert by sync_key
- Get by sync_key
- Delete by sync_key
- Set a sync on existing record (without sync_key)
- Create relationship based on sync_key
- Delete relationship based on sync_key
Use Sugar Bulk API
- Endpoint that encapsulates multiple API calls into one single HTTP request
- Requests are executed synchronously (one after the other)
- Reducing network latency between calls
- Combined with Upsert provides the best performance
- Careful not to add too many requests to it
- Start small (5 to 10 requests) and increase until you reach it's max capacity
Polling and filtering time-based with Filter API
- Integration gateway (or your external system) asks Sugar every X minutes
- Request Filter API using max_num (max number of records), offset and fields
- Response will provide the data as well as next_offset (offset can be seen as pagination)
- if next_offset is -1, no more records to go through
Initial Data Load into Sugar
- Use Bulk + Upsert to achieve data loads
- Millions of records may take a little while to process, plan ahead (over the weekend)
- Use multi-thread processes to load (for example 20 threads sending 20 bulk upsert requests)
- Careful with Sugar Cloud rate limits
- It's always a good idea to let Sugar Support know you're data loading, they will be considerate.
Understanding PHP limitations
- PHP allocates OS resources to process your request
- If you send too much data using bulk, you may run out of memory for that request
- Push to the limits but give some room for PHP to finish the request gracefully

You're up and running, but don't stop now - this is just the beginning of your journey. Now it's time to Customizations.

Integrations for Devs

Rafael Fernandes — Thu, 14 Jul 2022 15:41:24 GMT

Revision 16 posted to Dev Tutorials by Rafael Fernandes on 7/14/2022 3:41:24 PM

Integration Approaches

Sugar platform is extremely powerful and easy to integrate with. Determining the right approach for your use case scenario is the key to success.

Push/Pull from Sugar via REST API
- Recommended approach
- Developers have full control over integration
- Integration can be stopped and systems will continue to work
- Retry mechanism: Resume integrations at any time (bringing only delta changes through "last_udpdate_time" flags)
- Time delay from/to Sugar is minimum and bearable
- Sugar REST API offers everything you need, but can be extended
Push to Sugar, Sugar pushes to external queue in realtime
- Uses Sugar Events to trigger through Logic Hooks
- Requires Logic Hooks to be created and deployed
- Does not offer "retry mechanism", if a logic hook fails to deliver to a queue or contact external system
- Synchronous in nature, requires a response from external system
- Needs to handle dependencies manually (contact can only be created after account)
- Good to have a middleware/queue in front of Sugar to receive those event triggers (not mandatory but would make it "asynchronous"
Realtime: Embed your app into Sugar through Dashlets
- Simplest approach
- Often requires user-based authentication
- All load/traffic goes directly to your system, careful with bottlenecks

REST API Webservices

Sugar REST API Overview
- Fully RESTfull (GET, POST, PUT, DELETE)
- OAuth2 token based
- All fields and modules are available through the API automatically
- Metadata API provides everything you need to know about your Sugar instance.

Topics

Common APIs

Metadata
- Endpoint with current system's structure
- Modules, fields, relationships, layouts
- Use carefully, its payload can be MBs in size, cache as much as possible
- GET /metadata (use filters as much as possible)
- It does not retrieve lables for dropdowns, use language api to do so
- 3 Tips for using the Sugar Metadata API
Language
- Endpoint to retrieve labels
- Dropdown list values
- Any language specific content
- GET /lang/<language_code>
CRUD (Create, Read, Update, Delete) records
- Read: GET /<module>/:record
- Create: POST /<module>
- Update: PUT /<module>/:record
- Delete: DELETE /<module>/:record
- Filter: POST /<module>/filter
  - You can use GET as well
  - POST solves the issue when a query is too long and hits HTTP limits
- Retrieve records related to another module: GET /<module>/:record/link/:link_name
- Creates a relationship to a pre-existing record: POST /<module>/:record/link/:link_name/:remote_id

Performance and Best Practices

You should consider the following guidelines when implementing your integrations:

Use Sugar's sync_key
- Sugar provides in every module a sync_key field
- sync_key is a unique identifier for that module that links back to your external system's generated key
- For example, account ID from ERP is AC0001, set sync_key (pass as parameter in the POST) and sugar will create a record in account with sync_key=AC0001
- Next patch/update, sugar will check "where sync_key='AC0001'" and update it (it is indexed)
Use Sugar Integrate Upsert APIs
- Sugar's "update or insert" API based on sync_key
- Replaces commonly used check if exists, update or create (GET and POST or PUT)
- Upsert by sync_key
- Get by sync_key
- Delete by sync_key
- Set a sync on existing record (without sync_key)
- Create relationship based on sync_key
- Delete relationship based on sync_key
Use Sugar Bulk API
- Endpoint that encapsulates multiple API calls into one single HTTP request
- Requests are executed synchronously (one after the other)
- Reducing network latency between calls
- Combined with Upsert provides the best performance
- Careful not to add too many requests to it
- Start small (5 to 10 requests) and increase until you reach it's max capacity
Polling and filtering time-based with Filter API
- Integration gateway (or your external system) asks Sugar every X minutes
- Request Filter API using max_num (max number of records), offset and fields
- Response will provide the data as well as next_offset (offset can be seen as pagination)
- if next_offset is -1, no more records to go through
Initial Data Load into Sugar
- Use Bulk + Upsert to achieve data loads
- Millions of records may take a little while to process, plan ahead (over the weekend)
- Use multi-thread processes to load (for example 20 threads sending 20 bulk upsert requests)
- Careful with Sugar Cloud rate limits
- It's always a good idea to let Sugar Support know you're data loading, they will be considerate.
Understanding PHP limitations
- PHP allocates OS resources to process your request
- If you send too much data using bulk, you may run out of memory for that request
- Push to the limits but give some room for PHP to finish the request gracefully

You're up and running, but don't stop now - this is just the beginning of your journey. Now it's time to Customizations.

Integrations for Devs

Rafael Fernandes — Thu, 14 Jul 2022 15:41:08 GMT

Revision 15 posted to Dev Tutorials by Rafael Fernandes on 7/14/2022 3:41:08 PM

Integration Approaches

Sugar platform is extremely powerful and easy to integrate with. Determining the right approach for your use case scenario is the key to success.

Push/Pull from Sugar via REST API
- Recommended approach
- Developers have full control over integration
- Integration can be stopped and systems will continue to work
- Retry mechanism: Resume integrations at any time (bringing only delta changes through "last_udpdate_time" flags)
- Time delay from/to Sugar is minimum and bearable
- Sugar REST API offers everything you need, but can be extended
Push to Sugar, Sugar pushes to external queue in realtime
- Uses Sugar Events to trigger through Logic Hooks
- Requires Logic Hooks to be created and deployed
- Does not offer "retry mechanism", if a logic hook fails to deliver to a queue or contact external system
- Synchronous in nature, requires a response from external system
- Needs to handle dependencies manually (contact can only be created after account)
- Good to have a middleware/queue in front of Sugar to receive those event triggers (not mandatory but would make it "asynchronous"
Realtime: Embed your app into Sugar through Dashlets
- Simplest approach
- Often requires user-based authentication
- All load/traffic goes directly to your system, careful with bottlenecks

Webservices

Sugar REST API Overview
- Fully RESTfull (GET, POST, PUT, DELETE)
- OAuth2 token based
- All fields and modules are available through the API automatically
- Metadata API provides everything you need to know about your Sugar instance.

Topics

Common APIs

Metadata
- Endpoint with current system's structure
- Modules, fields, relationships, layouts
- Use carefully, its payload can be MBs in size, cache as much as possible
- GET /metadata (use filters as much as possible)
- It does not retrieve lables for dropdowns, use language api to do so
- 3 Tips for using the Sugar Metadata API
Language
- Endpoint to retrieve labels
- Dropdown list values
- Any language specific content
- GET /lang/<language_code>
CRUD (Create, Read, Update, Delete) records
- Read: GET /<module>/:record
- Create: POST /<module>
- Update: PUT /<module>/:record
- Delete: DELETE /<module>/:record
- Filter: POST /<module>/filter
  - You can use GET as well
  - POST solves the issue when a query is too long and hits HTTP limits
- Retrieve records related to another module: GET /<module>/:record/link/:link_name
- Creates a relationship to a pre-existing record: POST /<module>/:record/link/:link_name/:remote_id

Performance and Best Practices

You should consider the following guidelines when implementing your integrations:

Use Sugar's sync_key
- Sugar provides in every module a sync_key field
- sync_key is a unique identifier for that module that links back to your external system's generated key
- For example, account ID from ERP is AC0001, set sync_key (pass as parameter in the POST) and sugar will create a record in account with sync_key=AC0001
- Next patch/update, sugar will check "where sync_key='AC0001'" and update it (it is indexed)
Use Sugar Integrate Upsert APIs
- Sugar's "update or insert" API based on sync_key
- Replaces commonly used check if exists, update or create (GET and POST or PUT)
- Upsert by sync_key
- Get by sync_key
- Delete by sync_key
- Set a sync on existing record (without sync_key)
- Create relationship based on sync_key
- Delete relationship based on sync_key
Use Sugar Bulk API
- Endpoint that encapsulates multiple API calls into one single HTTP request
- Requests are executed synchronously (one after the other)
- Reducing network latency between calls
- Combined with Upsert provides the best performance
- Careful not to add too many requests to it
- Start small (5 to 10 requests) and increase until you reach it's max capacity
Polling and filtering time-based with Filter API
- Integration gateway (or your external system) asks Sugar every X minutes
- Request Filter API using max_num (max number of records), offset and fields
- Response will provide the data as well as next_offset (offset can be seen as pagination)
- if next_offset is -1, no more records to go through
Initial Data Load into Sugar
- Use Bulk + Upsert to achieve data loads
- Millions of records may take a little while to process, plan ahead (over the weekend)
- Use multi-thread processes to load (for example 20 threads sending 20 bulk upsert requests)
- Careful with Sugar Cloud rate limits
- It's always a good idea to let Sugar Support know you're data loading, they will be considerate.
Understanding PHP limitations
- PHP allocates OS resources to process your request
- If you send too much data using bulk, you may run out of memory for that request
- Push to the limits but give some room for PHP to finish the request gracefully

You're up and running, but don't stop now - this is just the beginning of your journey. Now it's time to Customizations.

Integrations for Devs

Rafael Fernandes — Thu, 14 Jul 2022 15:40:11 GMT

Revision 14 posted to Dev Tutorials by Rafael Fernandes on 7/14/2022 3:40:11 PM

Integration Approaches

Sugar platform is extremely powerful and easy to integrate with. Determining the right approach for your use case scenario is the key to success.

Push/Pull from Sugar via REST API
- Recommended approach
- Developers have full control over integration
- Integration can be stopped and systems will continue to work
- Retry mechanism: Resume integrations at any time (bringing only delta changes through "last_udpdate_time" flags)
- Time delay from/to Sugar is minimum and bearable
- Sugar REST API offers everything you need, but can be extended
Push to Sugar, Sugar pushes to external queue in realtime
- Uses Sugar Events to trigger through Logic Hooks
- Requires Logic Hooks to be created and deployed
- Does not offer "retry mechanism", if a logic hook fails to deliver to a queue or contact external system
- Synchronous in nature, requires a response from external system
- Needs to handle dependencies manually (contact can only be created after account)
- Good to have a middleware/queue in front of Sugar to receive those event triggers (not mandatory but would make it "asynchronous"
Realtime: Embed your app into Sugar through Dashlets
- Simplest approach
- Often requires user-based authentication
- All load/traffic goes directly to your system, careful with bottlenecks

Integrating with Sugar

Sugar REST API Overview
- Fully RESTfull (GET, POST, PUT, DELETE)
- OAuth2 token based
- All fields and modules are available through the API automatically
- Metadata API provides everything you need to know about your Sugar instance.

Topics

Common APIs

Metadata
- Endpoint with current system's structure
- Modules, fields, relationships, layouts
- Use carefully, its payload can be MBs in size, cache as much as possible
- GET /metadata (use filters as much as possible)
- It does not retrieve lables for dropdowns, use language api to do so
- 3 Tips for using the Sugar Metadata API
Language
- Endpoint to retrieve labels
- Dropdown list values
- Any language specific content
- GET /lang/<language_code>
CRUD (Create, Read, Update, Delete) records
- Read: GET /<module>/:record
- Create: POST /<module>
- Update: PUT /<module>/:record
- Delete: DELETE /<module>/:record
- Filter: POST /<module>/filter
  - You can use GET as well
  - POST solves the issue when a query is too long and hits HTTP limits
- Retrieve records related to another module: GET /<module>/:record/link/:link_name
- Creates a relationship to a pre-existing record: POST /<module>/:record/link/:link_name/:remote_id

Performance and Best Practices

You should consider the following guidelines when implementing your integrations:

Use Sugar's sync_key
- Sugar provides in every module a sync_key field
- sync_key is a unique identifier for that module that links back to your external system's generated key
- For example, account ID from ERP is AC0001, set sync_key (pass as parameter in the POST) and sugar will create a record in account with sync_key=AC0001
- Next patch/update, sugar will check "where sync_key='AC0001'" and update it (it is indexed)
Use Sugar Integrate Upsert APIs
- Sugar's "update or insert" API based on sync_key
- Replaces commonly used check if exists, update or create (GET and POST or PUT)
- Upsert by sync_key
- Get by sync_key
- Delete by sync_key
- Set a sync on existing record (without sync_key)
- Create relationship based on sync_key
- Delete relationship based on sync_key
Use Sugar Bulk API
- Endpoint that encapsulates multiple API calls into one single HTTP request
- Requests are executed synchronously (one after the other)
- Reducing network latency between calls
- Combined with Upsert provides the best performance
- Careful not to add too many requests to it
- Start small (5 to 10 requests) and increase until you reach it's max capacity
Polling and filtering time-based with Filter API
- Integration gateway (or your external system) asks Sugar every X minutes
- Request Filter API using max_num (max number of records), offset and fields
- Response will provide the data as well as next_offset (offset can be seen as pagination)
- if next_offset is -1, no more records to go through
Initial Data Load into Sugar
- Use Bulk + Upsert to achieve data loads
- Millions of records may take a little while to process, plan ahead (over the weekend)
- Use multi-thread processes to load (for example 20 threads sending 20 bulk upsert requests)
- Careful with Sugar Cloud rate limits
- It's always a good idea to let Sugar Support know you're data loading, they will be considerate.
Understanding PHP limitations
- PHP allocates OS resources to process your request
- If you send too much data using bulk, you may run out of memory for that request
- Push to the limits but give some room for PHP to finish the request gracefully

You're up and running, but don't stop now - this is just the beginning of your journey. Now it's time to Customizations.

Integrations for Devs

Rafael Fernandes — Thu, 14 Jul 2022 15:18:41 GMT

Revision 13 posted to Dev Tutorials by Rafael Fernandes on 7/14/2022 3:18:41 PM

Integration Approaches

Sugar platform is extremely powerful and easy to integrate with. Determining the right approach for your use case scenario is the key to success.

Push/Pull from Sugar via REST API
- Recommended approach
- Developers have full control over integration
- Integration can be stopped and systems will continue to work
- Retry mechanism: Resume integrations at any time (bringing only delta changes through "last_udpdate_time" flags)
- Time delay from/to Sugar is minimum and bearable
- Sugar REST API offers everything you need, but can be extended
Push to Sugar, Sugar pushes to external queue in realtime
- Uses Sugar Events to trigger through Logic Hooks
- Requires Logic Hooks to be created and deployed
- Does not offer "retry mechanism", if a logic hook fails to deliver to a queue or contact external system
- Synchronous in nature, requires a response from external system
- Needs to handle dependencies manually (contact can only be created after account)
- Good to have a middleware/queue in front of Sugar to receive those event triggers (not mandatory but would make it "asynchronous"
Realtime: Embed your app into Sugar through Dashlets
- Simplest approach
- Often requires user-based authentication
- All load/traffic goes directly to your system, careful with bottlenecks

Integrating with Sugar

Sugar REST API Overview
- Fully RESTfull (GET, POST, PUT, DELETE)
- OAuth2 token based
- All fields and modules are available through the API automatically
- Metadata API provides everything you need to know about your Sugar instance.

Topics

Common APIs

Metadata
- Endpoint with current system's structure
- Modules, fields, relationships, layouts
- Use carefully, its payload can be MBs in size, cache as much as possible
- GET /metadata (use filters as much as possible)
- It does not retrieve lables for dropdowns, use language api to do so
- 3 Tips for using the Sugar Metadata API
Language
- Endpoint to retrieve labels
- Dropdown list values
- Any language specific content
- GET /lang/<language_code>
CRUD (Create, Read, Update, Delete) records
- Read: GET /<module>/:record
- Create: POST /<module>
- Update: PUT /<module>/:record
- Delete: DELETE /<module>/:record
- Filter: POST /<module>/filter
  - You can use GET as well
  - POST solves the issue when a query is too long and hits HTTP limits
- Retrieve records related to another module: GET /<module>/:record/link/:link_name
- Creates a relationship to a pre-existing record: POST /<module>/:record/link/:link_name/:remote_id

Performance and Best Practices

You should consider the following guidelines when implementing your integrations:

Use Sugar's sync_key
- Sugar provides in every module a sync_key field
- sync_key is a unique identifier for that module that links back to your external system's generated key
- For example, account ID from ERP is AC0001, set sync_key (pass as parameter in the POST) and sugar will create a record in account with sync_key=AC0001
- Next patch/update, sugar will check "where sync_key='AC0001'" and update it (it is indexed)
Use Sugar Integrate Upsert APIs
- Sugar's "update or insert" API based on sync_key
- Replaces commonly used check if exists, update or create (GET and POST or PUT)
- Upsert by sync_key
- Get by sync_key
- Delete by sync_key
- Set a sync on existing record (without sync_key)
- Create relationship based on sync_key
- Delete relationship based on sync_key
Use Sugar Bulk API
Polling and filtering time-based with Filter API
Initial Data Load into Sugar
- Basic knowledge of process design is required.
- Basic knowledge of process standards such as BPMN is preferred. BPMN is a flowchart-based notation used to define business processes within an organization.
- You should know which business processes you want to automate in Sugar.
Introduction to Business Process Automation via SugarBPM
Getting Started With SugarBPM for Sugar Serve
Using SugarBPM to Notify a Team or User on Record Creation
Understanding Email Direction in Process Definitions
Understanding Round Robin Activities vs. Round Robin Actions

You're up and running, but don't stop now - this is just the beginning of your journey. Now it's time to Customizations.

Integrations for Devs

Rafael Fernandes — Thu, 14 Jul 2022 15:07:30 GMT

Revision 12 posted to Dev Tutorials by Rafael Fernandes on 7/14/2022 3:07:30 PM

Integration Approaches

Sugar platform is extremely powerful and easy to integrate with. Determining the right approach for your use case scenario is the key to success.

Push/Pull from Sugar via REST API
- Recommended approach
- Developers have full control over integration
- Integration can be stopped and systems will continue to work
- Retry mechanism: Resume integrations at any time (bringing only delta changes through "last_udpdate_time" flags)
- Time delay from/to Sugar is minimum and bearable
- Sugar REST API offers everything you need, but can be extended
Push to Sugar, Sugar pushes to external queue in realtime
- Uses Sugar Events to trigger through Logic Hooks
- Requires Logic Hooks to be created and deployed
- Does not offer "retry mechanism", if a logic hook fails to deliver to a queue or contact external system
- Synchronous in nature, requires a response from external system
- Needs to handle dependencies manually (contact can only be created after account)
- Good to have a middleware/queue in front of Sugar to receive those event triggers (not mandatory but would make it "asynchronous"
Realtime: Embed your app into Sugar through Dashlets
- Simplest approach
- Often requires user-based authentication
- All load/traffic goes directly to your system, careful with bottlenecks

Integrating with Sugar

Sugar REST API Overview
- Fully RESTfull (GET, POST, PUT, DELETE)
- OAuth2 token based
- All fields and modules are available through the API automatically
- Metadata API provides everything you need to know about your Sugar instance.

Topics

Common APIs

Metadata
- Endpoint with current system's structure
- Modules, fields, relationships, layouts
- Use carefully, its payload can be MBs in size, cache as much as possible
- GET /metadata (use filters as much as possible)
- It does not retrieve lables for dropdowns, use language api to do so
- 3 Tips for using the Sugar Metadata API
Language
- Endpoint to retrieve labels
- Dropdown list values
- Any language specific content
- GET /lang/<language_code>
CRUD (Create, Read, Update, Delete) records
- Read: GET /<module>/:record
- Create: POST /<module>
- Update: PUT /<module>/:record
- Delete: DELETE /<module>/:record
- Filter: POST /<module>/filter
  - You can use GET as well
  - POST solves the issue when a query is too long and hits HTTP limits
- Retrieve records related to another module: GET /<module>/:record/link/:link_name
- Creates a relationship to a pre-existing record: POST /<module>/:record/link/:link_name/:remote_id

Performance and Best Practices

You should consider the following guidelines when implementing your integrations:

Use Sugar's sync_key
- Sugar provides in every module a sync_key field
- sync_key is a unique identifier for that module that links back to your external system's generated key
- For example, account ID from ERP is AC0001, set sync_key (pass as parameter in the POST) and sugar will create a record in account with sync_key=AC0001
- Next patch/update, sugar will check "where sync_key='AC0001'" and update it (it is indexed)
Use Sugar Integrate Upsert APIs
- Sugar's "update or insert" API based on sync_key
- Replaces common
Use Sugar Bulk API
Polling and filtering time-based with Filter API
Initial Data Load into Sugar
- Basic knowledge of process design is required.
- Basic knowledge of process standards such as BPMN is preferred. BPMN is a flowchart-based notation used to define business processes within an organization.
- You should know which business processes you want to automate in Sugar.
Introduction to Business Process Automation via SugarBPM
Getting Started With SugarBPM for Sugar Serve
Using SugarBPM to Notify a Team or User on Record Creation
Understanding Email Direction in Process Definitions
Understanding Round Robin Activities vs. Round Robin Actions

You're up and running, but don't stop now - this is just the beginning of your journey. Now it's time to Customizations.

Integrations for Devs

Rafael Fernandes — Thu, 14 Jul 2022 13:53:10 GMT

Revision 11 posted to Dev Tutorials by Rafael Fernandes on 7/14/2022 1:53:10 PM

Integration Approaches

Sugar platform is extremely powerful and easy to integrate with. Determining the right approach for your use case scenario is the key to success.

Push/Pull from Sugar via REST API
- Recommended approach
- Developers have full control over integration
- Integration can be stopped and systems will continue to work
- Retry mechanism: Resume integrations at any time (bringing only delta changes through "last_udpdate_time" flags)
- Time delay from/to Sugar is minimum and bearable
- Sugar REST API offers everything you need, but can be extended
Push to Sugar, Sugar pushes to external queue in realtime
- Uses Sugar Events to trigger through Logic Hooks
- Requires Logic Hooks to be created and deployed
- Does not offer "retry mechanism", if a logic hook fails to deliver to a queue or contact external system
- Synchronous in nature, requires a response from external system
- Needs to handle dependencies manually (contact can only be created after account)
- Good to have a middleware/queue in front of Sugar to receive those event triggers (not mandatory but would make it "asynchronous"
Realtime: Embed your app into Sugar through Dashlets
- Simplest approach
- Often requires user-based authentication
- All load/traffic goes directly to your system, careful with bottlenecks

Integrating with Sugar

Sugar REST API Overview
- Fully RESTfull (GET, POST, PUT, DELETE)
- OAuth2 token based
- All fields and modules are available through the API automatically
- Metadata API provides everything you need to know about your Sugar instance.

Topics

Common APIs

Metadata
- Endpoint with current system's structure
- Modules, fields, relationships, layouts
- Use carefully, its payload can be MBs in size, cache as much as possible
- GET /metadata (use filters as much as possible)
- It does not retrieve lables for dropdowns, use language api to do so
- 3 Tips for using the Sugar Metadata API
Language
- Endpoint to retrieve labels
- Dropdown list values
- Any language specific content
- GET /lang/<language_code>
CRUD (Create, Read, Update, Delete) records
- Read: GET /<module>/:record
- Create: POST /<module>
- Update: PUT /<module>/:record
- Delete: DELETE /<module>/:record
- Filter: POST /<module>/filter
  - You can use GET as well
  - POST solves the issue when a query is too long and hits HTTP limits
- Retrieve records related to another module: GET /<module>/:record/link/:link_name
- Creates a relationship to a pre-existing record: POST /<module>/:record/link/:link_name/:remote_id

Performance and Best Practices

SugarBPM™ enables administrators to streamline common business processes by managing approvals, sales processes, call triaging, and more. SugarBPM is an easy-to-use business process management (BPM) and workflow tool that adds advanced BPM functionality to Sugar.

The SugarBPM suite features an extensive toolbox of modules that provide the ability to easily create digital forms and map out robust workflows using a drag-and-drop interface.

Prerequisites
- Basic knowledge of process design is required.
- Basic knowledge of process standards such as BPMN is preferred. BPMN is a flowchart-based notation used to define business processes within an organization.
- You should know which business processes you want to automate in Sugar.
SugarBPM Overview
Introduction to Business Process Automation via SugarBPM
Getting Started With SugarBPM for Sugar Serve
Using SugarBPM to Notify a Team or User on Record Creation
Understanding Email Direction in Process Definitions
Understanding Round Robin Activities vs. Round Robin Actions

You're up and running, but don't stop now - this is just the beginning of your journey. Now it's time to Customizations.

Integrations for Devs

Rafael Fernandes — Thu, 14 Jul 2022 13:03:07 GMT

Revision 10 posted to Dev Tutorials by Rafael Fernandes on 7/14/2022 1:03:07 PM

Integration Approaches

Sugar platform is extremely powerful and easy to integrate with. Determining the right approach for your use case scenario is the key to success.

Push/Pull from Sugar via REST API
- Recommended approach
- Developers have full control over integration
- Integration can be stopped and systems will continue to work
- Retry mechanism: Resume integrations at any time (bringing only delta changes through "last_udpdate_time" flags)
- Time delay from/to Sugar is minimum and bearable
- Sugar REST API offers everything you need, but can be extended
Push to Sugar, Sugar pushes to external queue in realtime
- Uses Sugar Events to trigger through Logic Hooks
- Requires Logic Hooks to be created and deployed
- Does not offer "retry mechanism", if a logic hook fails to deliver to a queue or contact external system
- Synchronous in nature, requires a response from external system
- Needs to handle dependencies manually (contact can only be created after account)
- Good to have a middleware/queue in front of Sugar to receive those event triggers (not mandatory but would make it "asynchronous"
Realtime: Embed your app into Sugar through Dashlets
- Simplest approach
- Often requires user-based authentication
- All load/traffic goes directly to your system, careful with bottlenecks

Integrating with Sugar

Sugar REST API Overview
- Fully RESTfull (GET, POST, PUT, DELETE)
- OAuth2 token based
- All fields and modules are available through the API automatically
- Metadata API provides everything you need to know about your Sugar instance.

Topics

Common APIs

Metadata
- Endpoint with current system's structure
- Modules, fields, relationships, layouts
- Use carefully, its payload can be MBs in size, cache as much as possible
- GET /metadata (use filters as much as possible)
- It does not retrieve lables for dropdowns, use language api to do so
- 3 Tips for using the Sugar Metadata API
Language
- Endpoint to retrieve labels
- Dropdown list values
- Any language specific content
- GET /lang/<language_code>
CRUD (Create, Read, Update, Delete) records
- Read: GET /<module>/:record
- Create: POST /<module>
- Update: PUT /<module>/:record
- Delete: DELETE /<module>/:record
- Filter: POST /<module>/filter
  - You can use GET as well
  - POST solves the issue when a query is too long and hits HTTP limits
- Retrieve records related to another module: GET /<module>/:record/link/:link_name
- Creates a relationship to a pre-existing record: POST /<module>/:record/link/:link_name/:remote_id

SugarBPM - Advanced Workflow

The SugarBPM suite features an extensive toolbox of modules that provide the ability to easily create digital forms and map out robust workflows using a drag-and-drop interface.

Prerequisites
- Basic knowledge of process design is required.
- Basic knowledge of process standards such as BPMN is preferred. BPMN is a flowchart-based notation used to define business processes within an organization.
- You should know which business processes you want to automate in Sugar.
SugarBPM Overview
Introduction to Business Process Automation via SugarBPM
Getting Started With SugarBPM for Sugar Serve
Using SugarBPM to Notify a Team or User on Record Creation
Understanding Email Direction in Process Definitions
Understanding Round Robin Activities vs. Round Robin Actions

You're up and running, but don't stop now - this is just the beginning of your journey. Now it's time to Customizations.

Integrations for Devs

Rafael Fernandes — Wed, 13 Jul 2022 18:27:27 GMT

Revision 9 posted to Dev Tutorials by Rafael Fernandes on 7/13/2022 6:27:27 PM

Integration Approaches

Sugar platform is extremely powerful and easy to integrate with. Determining the right approach for your use case scenario is the key to success.

Push/Pull from Sugar via REST API
- Recommended approach
- Developers have full control over integration
- Integration can be stopped and systems will continue to work
- Retry mechanism: Resume integrations at any time (bringing only delta changes through "last_udpdate_time" flags)
- Time delay from/to Sugar is minimum and bearable
- Sugar REST API offers everything you need, but can be extended
Push to Sugar, Sugar pushes to external queue in realtime
- Uses Sugar Events to trigger through Logic Hooks
- Requires Logic Hooks to be created and deployed
- Does not offer "retry mechanism", if a logic hook fails to deliver to a queue or contact external system
- Synchronous in nature, requires a response from external system
- Needs to handle dependencies manually (contact can only be created after account)
- Good to have a middleware/queue in front of Sugar to receive those event triggers (not mandatory but would make it "asynchronous"
Realtime: Embed your app into Sugar through Dashlets
- Simplest approach
- Often requires user-based authentication
- All load/traffic goes directly to your system, careful with bottlenecks

Integrating with Sugar

Sugar REST API Overview
- Fully RESTfull (GET, POST, PUT, DELETE)
- OAuth2 token based
- All fields and modules are available through the API automatically
- Metadata API provides everything you need to know about your Sugar instance.

Topics

Common APIs

todo

The Studio and Module Builder section includes topics covering creating, modifying, and troubleshooting custom fields, relationships, dropdown lists, and modules via Sugar's Studio and Module Builder tools:

SugarBPM - Advanced Workflow

The SugarBPM suite features an extensive toolbox of modules that provide the ability to easily create digital forms and map out robust workflows using a drag-and-drop interface.

Prerequisites
- Basic knowledge of process design is required.
- Basic knowledge of process standards such as BPMN is preferred. BPMN is a flowchart-based notation used to define business processes within an organization.
- You should know which business processes you want to automate in Sugar.
SugarBPM Overview
Introduction to Business Process Automation via SugarBPM
Getting Started With SugarBPM for Sugar Serve
Using SugarBPM to Notify a Team or User on Record Creation
Understanding Email Direction in Process Definitions
Understanding Round Robin Activities vs. Round Robin Actions